pulumi-checkly 2.3.0a1750944663__py3-none-any.whl → 2.4.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_checkly/__init__.py +27 -0
- pulumi_checkly/_inputs.py +2538 -153
- pulumi_checkly/check.py +47 -0
- pulumi_checkly/dashboard.py +396 -66
- pulumi_checkly/heartbeat_check.py +47 -4
- pulumi_checkly/heartbeat_monitor.py +527 -0
- pulumi_checkly/outputs.py +1989 -131
- pulumi_checkly/pulumi-plugin.json +1 -1
- pulumi_checkly/tcp_check.py +47 -4
- pulumi_checkly/tcp_monitor.py +1218 -0
- pulumi_checkly/url_monitor.py +1092 -0
- {pulumi_checkly-2.3.0a1750944663.dist-info → pulumi_checkly-2.4.0.dist-info}/METADATA +1 -1
- {pulumi_checkly-2.3.0a1750944663.dist-info → pulumi_checkly-2.4.0.dist-info}/RECORD +15 -12
- {pulumi_checkly-2.3.0a1750944663.dist-info → pulumi_checkly-2.4.0.dist-info}/WHEEL +0 -0
- {pulumi_checkly-2.3.0a1750944663.dist-info → pulumi_checkly-2.4.0.dist-info}/top_level.txt +0 -0
pulumi_checkly/_inputs.py
CHANGED
|
@@ -77,6 +77,8 @@ __all__ = [
|
|
|
77
77
|
'CheckRequestBasicAuthArgsDict',
|
|
78
78
|
'CheckRetryStrategyArgs',
|
|
79
79
|
'CheckRetryStrategyArgsDict',
|
|
80
|
+
'CheckTriggerIncidentArgs',
|
|
81
|
+
'CheckTriggerIncidentArgsDict',
|
|
80
82
|
'HeartbeatCheckAlertChannelSubscriptionArgs',
|
|
81
83
|
'HeartbeatCheckAlertChannelSubscriptionArgsDict',
|
|
82
84
|
'HeartbeatCheckAlertSettingsArgs',
|
|
@@ -93,6 +95,26 @@ __all__ = [
|
|
|
93
95
|
'HeartbeatCheckAlertSettingsTimeBasedEscalationArgsDict',
|
|
94
96
|
'HeartbeatCheckHeartbeatArgs',
|
|
95
97
|
'HeartbeatCheckHeartbeatArgsDict',
|
|
98
|
+
'HeartbeatCheckTriggerIncidentArgs',
|
|
99
|
+
'HeartbeatCheckTriggerIncidentArgsDict',
|
|
100
|
+
'HeartbeatMonitorAlertChannelSubscriptionArgs',
|
|
101
|
+
'HeartbeatMonitorAlertChannelSubscriptionArgsDict',
|
|
102
|
+
'HeartbeatMonitorAlertSettingsArgs',
|
|
103
|
+
'HeartbeatMonitorAlertSettingsArgsDict',
|
|
104
|
+
'HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgs',
|
|
105
|
+
'HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
106
|
+
'HeartbeatMonitorAlertSettingsReminderArgs',
|
|
107
|
+
'HeartbeatMonitorAlertSettingsReminderArgsDict',
|
|
108
|
+
'HeartbeatMonitorAlertSettingsRunBasedEscalationArgs',
|
|
109
|
+
'HeartbeatMonitorAlertSettingsRunBasedEscalationArgsDict',
|
|
110
|
+
'HeartbeatMonitorAlertSettingsSslCertificateArgs',
|
|
111
|
+
'HeartbeatMonitorAlertSettingsSslCertificateArgsDict',
|
|
112
|
+
'HeartbeatMonitorAlertSettingsTimeBasedEscalationArgs',
|
|
113
|
+
'HeartbeatMonitorAlertSettingsTimeBasedEscalationArgsDict',
|
|
114
|
+
'HeartbeatMonitorHeartbeatArgs',
|
|
115
|
+
'HeartbeatMonitorHeartbeatArgsDict',
|
|
116
|
+
'HeartbeatMonitorTriggerIncidentArgs',
|
|
117
|
+
'HeartbeatMonitorTriggerIncidentArgsDict',
|
|
96
118
|
'StatusPageCardArgs',
|
|
97
119
|
'StatusPageCardArgsDict',
|
|
98
120
|
'StatusPageCardServiceAttachmentArgs',
|
|
@@ -115,6 +137,48 @@ __all__ = [
|
|
|
115
137
|
'TcpCheckRequestAssertionArgsDict',
|
|
116
138
|
'TcpCheckRetryStrategyArgs',
|
|
117
139
|
'TcpCheckRetryStrategyArgsDict',
|
|
140
|
+
'TcpCheckTriggerIncidentArgs',
|
|
141
|
+
'TcpCheckTriggerIncidentArgsDict',
|
|
142
|
+
'TcpMonitorAlertChannelSubscriptionArgs',
|
|
143
|
+
'TcpMonitorAlertChannelSubscriptionArgsDict',
|
|
144
|
+
'TcpMonitorAlertSettingsArgs',
|
|
145
|
+
'TcpMonitorAlertSettingsArgsDict',
|
|
146
|
+
'TcpMonitorAlertSettingsParallelRunFailureThresholdArgs',
|
|
147
|
+
'TcpMonitorAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
148
|
+
'TcpMonitorAlertSettingsReminderArgs',
|
|
149
|
+
'TcpMonitorAlertSettingsReminderArgsDict',
|
|
150
|
+
'TcpMonitorAlertSettingsRunBasedEscalationArgs',
|
|
151
|
+
'TcpMonitorAlertSettingsRunBasedEscalationArgsDict',
|
|
152
|
+
'TcpMonitorAlertSettingsTimeBasedEscalationArgs',
|
|
153
|
+
'TcpMonitorAlertSettingsTimeBasedEscalationArgsDict',
|
|
154
|
+
'TcpMonitorRequestArgs',
|
|
155
|
+
'TcpMonitorRequestArgsDict',
|
|
156
|
+
'TcpMonitorRequestAssertionArgs',
|
|
157
|
+
'TcpMonitorRequestAssertionArgsDict',
|
|
158
|
+
'TcpMonitorRetryStrategyArgs',
|
|
159
|
+
'TcpMonitorRetryStrategyArgsDict',
|
|
160
|
+
'TcpMonitorTriggerIncidentArgs',
|
|
161
|
+
'TcpMonitorTriggerIncidentArgsDict',
|
|
162
|
+
'UrlMonitorAlertChannelSubscriptionArgs',
|
|
163
|
+
'UrlMonitorAlertChannelSubscriptionArgsDict',
|
|
164
|
+
'UrlMonitorAlertSettingsArgs',
|
|
165
|
+
'UrlMonitorAlertSettingsArgsDict',
|
|
166
|
+
'UrlMonitorAlertSettingsParallelRunFailureThresholdArgs',
|
|
167
|
+
'UrlMonitorAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
168
|
+
'UrlMonitorAlertSettingsReminderArgs',
|
|
169
|
+
'UrlMonitorAlertSettingsReminderArgsDict',
|
|
170
|
+
'UrlMonitorAlertSettingsRunBasedEscalationArgs',
|
|
171
|
+
'UrlMonitorAlertSettingsRunBasedEscalationArgsDict',
|
|
172
|
+
'UrlMonitorAlertSettingsTimeBasedEscalationArgs',
|
|
173
|
+
'UrlMonitorAlertSettingsTimeBasedEscalationArgsDict',
|
|
174
|
+
'UrlMonitorRequestArgs',
|
|
175
|
+
'UrlMonitorRequestArgsDict',
|
|
176
|
+
'UrlMonitorRequestAssertionArgs',
|
|
177
|
+
'UrlMonitorRequestAssertionArgsDict',
|
|
178
|
+
'UrlMonitorRetryStrategyArgs',
|
|
179
|
+
'UrlMonitorRetryStrategyArgsDict',
|
|
180
|
+
'UrlMonitorTriggerIncidentArgs',
|
|
181
|
+
'UrlMonitorTriggerIncidentArgsDict',
|
|
118
182
|
]
|
|
119
183
|
|
|
120
184
|
MYPY = False
|
|
@@ -2087,6 +2151,113 @@ class CheckRetryStrategyArgs:
|
|
|
2087
2151
|
pulumi.set(self, "same_region", value)
|
|
2088
2152
|
|
|
2089
2153
|
|
|
2154
|
+
if not MYPY:
|
|
2155
|
+
class CheckTriggerIncidentArgsDict(TypedDict):
|
|
2156
|
+
description: pulumi.Input[str]
|
|
2157
|
+
"""
|
|
2158
|
+
A detailed description of the incident.
|
|
2159
|
+
"""
|
|
2160
|
+
name: pulumi.Input[str]
|
|
2161
|
+
"""
|
|
2162
|
+
The name of the incident.
|
|
2163
|
+
"""
|
|
2164
|
+
notify_subscribers: pulumi.Input[bool]
|
|
2165
|
+
"""
|
|
2166
|
+
Whether to notify subscribers when the incident is triggered.
|
|
2167
|
+
"""
|
|
2168
|
+
service_id: pulumi.Input[str]
|
|
2169
|
+
"""
|
|
2170
|
+
The status page service that this incident will be associated with.
|
|
2171
|
+
"""
|
|
2172
|
+
severity: pulumi.Input[str]
|
|
2173
|
+
"""
|
|
2174
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2175
|
+
"""
|
|
2176
|
+
elif False:
|
|
2177
|
+
CheckTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
2178
|
+
|
|
2179
|
+
@pulumi.input_type
|
|
2180
|
+
class CheckTriggerIncidentArgs:
|
|
2181
|
+
def __init__(__self__, *,
|
|
2182
|
+
description: pulumi.Input[str],
|
|
2183
|
+
name: pulumi.Input[str],
|
|
2184
|
+
notify_subscribers: pulumi.Input[bool],
|
|
2185
|
+
service_id: pulumi.Input[str],
|
|
2186
|
+
severity: pulumi.Input[str]):
|
|
2187
|
+
"""
|
|
2188
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
2189
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
2190
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
2191
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
2192
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2193
|
+
"""
|
|
2194
|
+
pulumi.set(__self__, "description", description)
|
|
2195
|
+
pulumi.set(__self__, "name", name)
|
|
2196
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
2197
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
2198
|
+
pulumi.set(__self__, "severity", severity)
|
|
2199
|
+
|
|
2200
|
+
@property
|
|
2201
|
+
@pulumi.getter
|
|
2202
|
+
def description(self) -> pulumi.Input[str]:
|
|
2203
|
+
"""
|
|
2204
|
+
A detailed description of the incident.
|
|
2205
|
+
"""
|
|
2206
|
+
return pulumi.get(self, "description")
|
|
2207
|
+
|
|
2208
|
+
@description.setter
|
|
2209
|
+
def description(self, value: pulumi.Input[str]):
|
|
2210
|
+
pulumi.set(self, "description", value)
|
|
2211
|
+
|
|
2212
|
+
@property
|
|
2213
|
+
@pulumi.getter
|
|
2214
|
+
def name(self) -> pulumi.Input[str]:
|
|
2215
|
+
"""
|
|
2216
|
+
The name of the incident.
|
|
2217
|
+
"""
|
|
2218
|
+
return pulumi.get(self, "name")
|
|
2219
|
+
|
|
2220
|
+
@name.setter
|
|
2221
|
+
def name(self, value: pulumi.Input[str]):
|
|
2222
|
+
pulumi.set(self, "name", value)
|
|
2223
|
+
|
|
2224
|
+
@property
|
|
2225
|
+
@pulumi.getter(name="notifySubscribers")
|
|
2226
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
2227
|
+
"""
|
|
2228
|
+
Whether to notify subscribers when the incident is triggered.
|
|
2229
|
+
"""
|
|
2230
|
+
return pulumi.get(self, "notify_subscribers")
|
|
2231
|
+
|
|
2232
|
+
@notify_subscribers.setter
|
|
2233
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
2234
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
2235
|
+
|
|
2236
|
+
@property
|
|
2237
|
+
@pulumi.getter(name="serviceId")
|
|
2238
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
2239
|
+
"""
|
|
2240
|
+
The status page service that this incident will be associated with.
|
|
2241
|
+
"""
|
|
2242
|
+
return pulumi.get(self, "service_id")
|
|
2243
|
+
|
|
2244
|
+
@service_id.setter
|
|
2245
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
2246
|
+
pulumi.set(self, "service_id", value)
|
|
2247
|
+
|
|
2248
|
+
@property
|
|
2249
|
+
@pulumi.getter
|
|
2250
|
+
def severity(self) -> pulumi.Input[str]:
|
|
2251
|
+
"""
|
|
2252
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2253
|
+
"""
|
|
2254
|
+
return pulumi.get(self, "severity")
|
|
2255
|
+
|
|
2256
|
+
@severity.setter
|
|
2257
|
+
def severity(self, value: pulumi.Input[str]):
|
|
2258
|
+
pulumi.set(self, "severity", value)
|
|
2259
|
+
|
|
2260
|
+
|
|
2090
2261
|
if not MYPY:
|
|
2091
2262
|
class HeartbeatCheckAlertChannelSubscriptionArgsDict(TypedDict):
|
|
2092
2263
|
activated: pulumi.Input[bool]
|
|
@@ -2551,35 +2722,68 @@ class HeartbeatCheckHeartbeatArgs:
|
|
|
2551
2722
|
|
|
2552
2723
|
|
|
2553
2724
|
if not MYPY:
|
|
2554
|
-
class
|
|
2725
|
+
class HeartbeatCheckTriggerIncidentArgsDict(TypedDict):
|
|
2726
|
+
description: pulumi.Input[str]
|
|
2727
|
+
"""
|
|
2728
|
+
A detailed description of the incident.
|
|
2729
|
+
"""
|
|
2555
2730
|
name: pulumi.Input[str]
|
|
2556
2731
|
"""
|
|
2557
|
-
The name of the
|
|
2732
|
+
The name of the incident.
|
|
2558
2733
|
"""
|
|
2559
|
-
|
|
2734
|
+
notify_subscribers: pulumi.Input[bool]
|
|
2560
2735
|
"""
|
|
2561
|
-
|
|
2736
|
+
Whether to notify subscribers when the incident is triggered.
|
|
2737
|
+
"""
|
|
2738
|
+
service_id: pulumi.Input[str]
|
|
2739
|
+
"""
|
|
2740
|
+
The status page service that this incident will be associated with.
|
|
2741
|
+
"""
|
|
2742
|
+
severity: pulumi.Input[str]
|
|
2743
|
+
"""
|
|
2744
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2562
2745
|
"""
|
|
2563
2746
|
elif False:
|
|
2564
|
-
|
|
2747
|
+
HeartbeatCheckTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
2565
2748
|
|
|
2566
2749
|
@pulumi.input_type
|
|
2567
|
-
class
|
|
2750
|
+
class HeartbeatCheckTriggerIncidentArgs:
|
|
2568
2751
|
def __init__(__self__, *,
|
|
2752
|
+
description: pulumi.Input[str],
|
|
2569
2753
|
name: pulumi.Input[str],
|
|
2570
|
-
|
|
2754
|
+
notify_subscribers: pulumi.Input[bool],
|
|
2755
|
+
service_id: pulumi.Input[str],
|
|
2756
|
+
severity: pulumi.Input[str]):
|
|
2571
2757
|
"""
|
|
2572
|
-
:param pulumi.Input[str]
|
|
2573
|
-
:param pulumi.Input[
|
|
2758
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
2759
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
2760
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
2761
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
2762
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2574
2763
|
"""
|
|
2764
|
+
pulumi.set(__self__, "description", description)
|
|
2575
2765
|
pulumi.set(__self__, "name", name)
|
|
2576
|
-
pulumi.set(__self__, "
|
|
2766
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
2767
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
2768
|
+
pulumi.set(__self__, "severity", severity)
|
|
2769
|
+
|
|
2770
|
+
@property
|
|
2771
|
+
@pulumi.getter
|
|
2772
|
+
def description(self) -> pulumi.Input[str]:
|
|
2773
|
+
"""
|
|
2774
|
+
A detailed description of the incident.
|
|
2775
|
+
"""
|
|
2776
|
+
return pulumi.get(self, "description")
|
|
2777
|
+
|
|
2778
|
+
@description.setter
|
|
2779
|
+
def description(self, value: pulumi.Input[str]):
|
|
2780
|
+
pulumi.set(self, "description", value)
|
|
2577
2781
|
|
|
2578
2782
|
@property
|
|
2579
2783
|
@pulumi.getter
|
|
2580
2784
|
def name(self) -> pulumi.Input[str]:
|
|
2581
2785
|
"""
|
|
2582
|
-
The name of the
|
|
2786
|
+
The name of the incident.
|
|
2583
2787
|
"""
|
|
2584
2788
|
return pulumi.get(self, "name")
|
|
2585
2789
|
|
|
@@ -2588,41 +2792,22 @@ class StatusPageCardArgs:
|
|
|
2588
2792
|
pulumi.set(self, "name", value)
|
|
2589
2793
|
|
|
2590
2794
|
@property
|
|
2591
|
-
@pulumi.getter(name="
|
|
2592
|
-
def
|
|
2593
|
-
"""
|
|
2594
|
-
A list of services to attach to the card.
|
|
2595
|
-
"""
|
|
2596
|
-
return pulumi.get(self, "service_attachments")
|
|
2597
|
-
|
|
2598
|
-
@service_attachments.setter
|
|
2599
|
-
def service_attachments(self, value: pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgs']]]):
|
|
2600
|
-
pulumi.set(self, "service_attachments", value)
|
|
2601
|
-
|
|
2602
|
-
|
|
2603
|
-
if not MYPY:
|
|
2604
|
-
class StatusPageCardServiceAttachmentArgsDict(TypedDict):
|
|
2605
|
-
service_id: pulumi.Input[str]
|
|
2795
|
+
@pulumi.getter(name="notifySubscribers")
|
|
2796
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
2606
2797
|
"""
|
|
2607
|
-
|
|
2798
|
+
Whether to notify subscribers when the incident is triggered.
|
|
2608
2799
|
"""
|
|
2609
|
-
|
|
2610
|
-
StatusPageCardServiceAttachmentArgsDict: TypeAlias = Mapping[str, Any]
|
|
2800
|
+
return pulumi.get(self, "notify_subscribers")
|
|
2611
2801
|
|
|
2612
|
-
@
|
|
2613
|
-
|
|
2614
|
-
|
|
2615
|
-
service_id: pulumi.Input[str]):
|
|
2616
|
-
"""
|
|
2617
|
-
:param pulumi.Input[str] service_id: The ID of the service.
|
|
2618
|
-
"""
|
|
2619
|
-
pulumi.set(__self__, "service_id", service_id)
|
|
2802
|
+
@notify_subscribers.setter
|
|
2803
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
2804
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
2620
2805
|
|
|
2621
2806
|
@property
|
|
2622
2807
|
@pulumi.getter(name="serviceId")
|
|
2623
2808
|
def service_id(self) -> pulumi.Input[str]:
|
|
2624
2809
|
"""
|
|
2625
|
-
The
|
|
2810
|
+
The status page service that this incident will be associated with.
|
|
2626
2811
|
"""
|
|
2627
2812
|
return pulumi.get(self, "service_id")
|
|
2628
2813
|
|
|
@@ -2630,16 +2815,28 @@ class StatusPageCardServiceAttachmentArgs:
|
|
|
2630
2815
|
def service_id(self, value: pulumi.Input[str]):
|
|
2631
2816
|
pulumi.set(self, "service_id", value)
|
|
2632
2817
|
|
|
2818
|
+
@property
|
|
2819
|
+
@pulumi.getter
|
|
2820
|
+
def severity(self) -> pulumi.Input[str]:
|
|
2821
|
+
"""
|
|
2822
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
2823
|
+
"""
|
|
2824
|
+
return pulumi.get(self, "severity")
|
|
2825
|
+
|
|
2826
|
+
@severity.setter
|
|
2827
|
+
def severity(self, value: pulumi.Input[str]):
|
|
2828
|
+
pulumi.set(self, "severity", value)
|
|
2829
|
+
|
|
2633
2830
|
|
|
2634
2831
|
if not MYPY:
|
|
2635
|
-
class
|
|
2832
|
+
class HeartbeatMonitorAlertChannelSubscriptionArgsDict(TypedDict):
|
|
2636
2833
|
activated: pulumi.Input[bool]
|
|
2637
2834
|
channel_id: pulumi.Input[int]
|
|
2638
2835
|
elif False:
|
|
2639
|
-
|
|
2836
|
+
HeartbeatMonitorAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2640
2837
|
|
|
2641
2838
|
@pulumi.input_type
|
|
2642
|
-
class
|
|
2839
|
+
class HeartbeatMonitorAlertChannelSubscriptionArgs:
|
|
2643
2840
|
def __init__(__self__, *,
|
|
2644
2841
|
activated: pulumi.Input[bool],
|
|
2645
2842
|
channel_id: pulumi.Input[int]):
|
|
@@ -2666,26 +2863,28 @@ class TcpCheckAlertChannelSubscriptionArgs:
|
|
|
2666
2863
|
|
|
2667
2864
|
|
|
2668
2865
|
if not MYPY:
|
|
2669
|
-
class
|
|
2866
|
+
class HeartbeatMonitorAlertSettingsArgsDict(TypedDict):
|
|
2670
2867
|
escalation_type: NotRequired[pulumi.Input[str]]
|
|
2671
2868
|
"""
|
|
2672
2869
|
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2673
2870
|
"""
|
|
2674
|
-
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['
|
|
2675
|
-
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['
|
|
2676
|
-
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['
|
|
2677
|
-
|
|
2871
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
2872
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsReminderArgsDict']]]]
|
|
2873
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
2874
|
+
ssl_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsSslCertificateArgsDict']]]]
|
|
2875
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
2678
2876
|
elif False:
|
|
2679
|
-
|
|
2877
|
+
HeartbeatMonitorAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2680
2878
|
|
|
2681
2879
|
@pulumi.input_type
|
|
2682
|
-
class
|
|
2880
|
+
class HeartbeatMonitorAlertSettingsArgs:
|
|
2683
2881
|
def __init__(__self__, *,
|
|
2684
2882
|
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
2685
|
-
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2686
|
-
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2687
|
-
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2688
|
-
|
|
2883
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
2884
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsReminderArgs']]]] = None,
|
|
2885
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
2886
|
+
ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsSslCertificateArgs']]]] = None,
|
|
2887
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
2689
2888
|
"""
|
|
2690
2889
|
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2691
2890
|
"""
|
|
@@ -2697,6 +2896,11 @@ class TcpCheckAlertSettingsArgs:
|
|
|
2697
2896
|
pulumi.set(__self__, "reminders", reminders)
|
|
2698
2897
|
if run_based_escalations is not None:
|
|
2699
2898
|
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
2899
|
+
if ssl_certificates is not None:
|
|
2900
|
+
warnings.warn("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""", DeprecationWarning)
|
|
2901
|
+
pulumi.log.warn("""ssl_certificates is deprecated: This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
2902
|
+
if ssl_certificates is not None:
|
|
2903
|
+
pulumi.set(__self__, "ssl_certificates", ssl_certificates)
|
|
2700
2904
|
if time_based_escalations is not None:
|
|
2701
2905
|
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
2702
2906
|
|
|
@@ -2714,43 +2918,53 @@ class TcpCheckAlertSettingsArgs:
|
|
|
2714
2918
|
|
|
2715
2919
|
@property
|
|
2716
2920
|
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
2717
|
-
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2921
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
2718
2922
|
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
2719
2923
|
|
|
2720
2924
|
@parallel_run_failure_thresholds.setter
|
|
2721
|
-
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2925
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
2722
2926
|
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
2723
2927
|
|
|
2724
2928
|
@property
|
|
2725
2929
|
@pulumi.getter
|
|
2726
|
-
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2930
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsReminderArgs']]]]:
|
|
2727
2931
|
return pulumi.get(self, "reminders")
|
|
2728
2932
|
|
|
2729
2933
|
@reminders.setter
|
|
2730
|
-
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2934
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsReminderArgs']]]]):
|
|
2731
2935
|
pulumi.set(self, "reminders", value)
|
|
2732
2936
|
|
|
2733
2937
|
@property
|
|
2734
2938
|
@pulumi.getter(name="runBasedEscalations")
|
|
2735
|
-
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2939
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsRunBasedEscalationArgs']]]]:
|
|
2736
2940
|
return pulumi.get(self, "run_based_escalations")
|
|
2737
2941
|
|
|
2738
2942
|
@run_based_escalations.setter
|
|
2739
|
-
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2943
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsRunBasedEscalationArgs']]]]):
|
|
2740
2944
|
pulumi.set(self, "run_based_escalations", value)
|
|
2741
2945
|
|
|
2946
|
+
@property
|
|
2947
|
+
@pulumi.getter(name="sslCertificates")
|
|
2948
|
+
@_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
2949
|
+
def ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsSslCertificateArgs']]]]:
|
|
2950
|
+
return pulumi.get(self, "ssl_certificates")
|
|
2951
|
+
|
|
2952
|
+
@ssl_certificates.setter
|
|
2953
|
+
def ssl_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsSslCertificateArgs']]]]):
|
|
2954
|
+
pulumi.set(self, "ssl_certificates", value)
|
|
2955
|
+
|
|
2742
2956
|
@property
|
|
2743
2957
|
@pulumi.getter(name="timeBasedEscalations")
|
|
2744
|
-
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2958
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
2745
2959
|
return pulumi.get(self, "time_based_escalations")
|
|
2746
2960
|
|
|
2747
2961
|
@time_based_escalations.setter
|
|
2748
|
-
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
2962
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatMonitorAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
2749
2963
|
pulumi.set(self, "time_based_escalations", value)
|
|
2750
2964
|
|
|
2751
2965
|
|
|
2752
2966
|
if not MYPY:
|
|
2753
|
-
class
|
|
2967
|
+
class HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
2754
2968
|
enabled: NotRequired[pulumi.Input[bool]]
|
|
2755
2969
|
"""
|
|
2756
2970
|
Applicable only for checks scheduled in parallel in multiple locations.
|
|
@@ -2760,10 +2974,10 @@ if not MYPY:
|
|
|
2760
2974
|
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2761
2975
|
"""
|
|
2762
2976
|
elif False:
|
|
2763
|
-
|
|
2977
|
+
HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
2764
2978
|
|
|
2765
2979
|
@pulumi.input_type
|
|
2766
|
-
class
|
|
2980
|
+
class HeartbeatMonitorAlertSettingsParallelRunFailureThresholdArgs:
|
|
2767
2981
|
def __init__(__self__, *,
|
|
2768
2982
|
enabled: Optional[pulumi.Input[bool]] = None,
|
|
2769
2983
|
percentage: Optional[pulumi.Input[int]] = None):
|
|
@@ -2802,7 +3016,7 @@ class TcpCheckAlertSettingsParallelRunFailureThresholdArgs:
|
|
|
2802
3016
|
|
|
2803
3017
|
|
|
2804
3018
|
if not MYPY:
|
|
2805
|
-
class
|
|
3019
|
+
class HeartbeatMonitorAlertSettingsReminderArgsDict(TypedDict):
|
|
2806
3020
|
amount: NotRequired[pulumi.Input[int]]
|
|
2807
3021
|
"""
|
|
2808
3022
|
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
@@ -2812,10 +3026,10 @@ if not MYPY:
|
|
|
2812
3026
|
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2813
3027
|
"""
|
|
2814
3028
|
elif False:
|
|
2815
|
-
|
|
3029
|
+
HeartbeatMonitorAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2816
3030
|
|
|
2817
3031
|
@pulumi.input_type
|
|
2818
|
-
class
|
|
3032
|
+
class HeartbeatMonitorAlertSettingsReminderArgs:
|
|
2819
3033
|
def __init__(__self__, *,
|
|
2820
3034
|
amount: Optional[pulumi.Input[int]] = None,
|
|
2821
3035
|
interval: Optional[pulumi.Input[int]] = None):
|
|
@@ -2854,16 +3068,16 @@ class TcpCheckAlertSettingsReminderArgs:
|
|
|
2854
3068
|
|
|
2855
3069
|
|
|
2856
3070
|
if not MYPY:
|
|
2857
|
-
class
|
|
3071
|
+
class HeartbeatMonitorAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
2858
3072
|
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
2859
3073
|
"""
|
|
2860
3074
|
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2861
3075
|
"""
|
|
2862
3076
|
elif False:
|
|
2863
|
-
|
|
3077
|
+
HeartbeatMonitorAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2864
3078
|
|
|
2865
3079
|
@pulumi.input_type
|
|
2866
|
-
class
|
|
3080
|
+
class HeartbeatMonitorAlertSettingsRunBasedEscalationArgs:
|
|
2867
3081
|
def __init__(__self__, *,
|
|
2868
3082
|
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
2869
3083
|
"""
|
|
@@ -2886,16 +3100,68 @@ class TcpCheckAlertSettingsRunBasedEscalationArgs:
|
|
|
2886
3100
|
|
|
2887
3101
|
|
|
2888
3102
|
if not MYPY:
|
|
2889
|
-
class
|
|
3103
|
+
class HeartbeatMonitorAlertSettingsSslCertificateArgsDict(TypedDict):
|
|
3104
|
+
alert_threshold: NotRequired[pulumi.Input[int]]
|
|
3105
|
+
"""
|
|
3106
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
3107
|
+
"""
|
|
3108
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
3109
|
+
"""
|
|
3110
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
3111
|
+
"""
|
|
3112
|
+
elif False:
|
|
3113
|
+
HeartbeatMonitorAlertSettingsSslCertificateArgsDict: TypeAlias = Mapping[str, Any]
|
|
3114
|
+
|
|
3115
|
+
@pulumi.input_type
|
|
3116
|
+
class HeartbeatMonitorAlertSettingsSslCertificateArgs:
|
|
3117
|
+
def __init__(__self__, *,
|
|
3118
|
+
alert_threshold: Optional[pulumi.Input[int]] = None,
|
|
3119
|
+
enabled: Optional[pulumi.Input[bool]] = None):
|
|
3120
|
+
"""
|
|
3121
|
+
:param pulumi.Input[int] alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
3122
|
+
:param pulumi.Input[bool] enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
3123
|
+
"""
|
|
3124
|
+
if alert_threshold is not None:
|
|
3125
|
+
pulumi.set(__self__, "alert_threshold", alert_threshold)
|
|
3126
|
+
if enabled is not None:
|
|
3127
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
3128
|
+
|
|
3129
|
+
@property
|
|
3130
|
+
@pulumi.getter(name="alertThreshold")
|
|
3131
|
+
def alert_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
3132
|
+
"""
|
|
3133
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
3134
|
+
"""
|
|
3135
|
+
return pulumi.get(self, "alert_threshold")
|
|
3136
|
+
|
|
3137
|
+
@alert_threshold.setter
|
|
3138
|
+
def alert_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
3139
|
+
pulumi.set(self, "alert_threshold", value)
|
|
3140
|
+
|
|
3141
|
+
@property
|
|
3142
|
+
@pulumi.getter
|
|
3143
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
3144
|
+
"""
|
|
3145
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
3146
|
+
"""
|
|
3147
|
+
return pulumi.get(self, "enabled")
|
|
3148
|
+
|
|
3149
|
+
@enabled.setter
|
|
3150
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
3151
|
+
pulumi.set(self, "enabled", value)
|
|
3152
|
+
|
|
3153
|
+
|
|
3154
|
+
if not MYPY:
|
|
3155
|
+
class HeartbeatMonitorAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
2890
3156
|
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
2891
3157
|
"""
|
|
2892
3158
|
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2893
3159
|
"""
|
|
2894
3160
|
elif False:
|
|
2895
|
-
|
|
3161
|
+
HeartbeatMonitorAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2896
3162
|
|
|
2897
3163
|
@pulumi.input_type
|
|
2898
|
-
class
|
|
3164
|
+
class HeartbeatMonitorAlertSettingsTimeBasedEscalationArgs:
|
|
2899
3165
|
def __init__(__self__, *,
|
|
2900
3166
|
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
2901
3167
|
"""
|
|
@@ -2918,44 +3184,1316 @@ class TcpCheckAlertSettingsTimeBasedEscalationArgs:
|
|
|
2918
3184
|
|
|
2919
3185
|
|
|
2920
3186
|
if not MYPY:
|
|
2921
|
-
class
|
|
2922
|
-
|
|
3187
|
+
class HeartbeatMonitorHeartbeatArgsDict(TypedDict):
|
|
3188
|
+
grace: pulumi.Input[int]
|
|
2923
3189
|
"""
|
|
2924
|
-
|
|
3190
|
+
How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
2925
3191
|
"""
|
|
2926
|
-
|
|
3192
|
+
grace_unit: pulumi.Input[str]
|
|
2927
3193
|
"""
|
|
2928
|
-
|
|
3194
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2929
3195
|
"""
|
|
2930
|
-
|
|
3196
|
+
period: pulumi.Input[int]
|
|
2931
3197
|
"""
|
|
2932
|
-
|
|
3198
|
+
How often you expect a ping to the ping URL.
|
|
2933
3199
|
"""
|
|
2934
|
-
|
|
3200
|
+
period_unit: pulumi.Input[str]
|
|
2935
3201
|
"""
|
|
2936
|
-
|
|
3202
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2937
3203
|
"""
|
|
2938
|
-
|
|
3204
|
+
ping_token: NotRequired[pulumi.Input[str]]
|
|
2939
3205
|
"""
|
|
2940
|
-
|
|
3206
|
+
Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
2941
3207
|
"""
|
|
2942
3208
|
elif False:
|
|
2943
|
-
|
|
3209
|
+
HeartbeatMonitorHeartbeatArgsDict: TypeAlias = Mapping[str, Any]
|
|
2944
3210
|
|
|
2945
3211
|
@pulumi.input_type
|
|
2946
|
-
class
|
|
3212
|
+
class HeartbeatMonitorHeartbeatArgs:
|
|
2947
3213
|
def __init__(__self__, *,
|
|
2948
|
-
|
|
2949
|
-
|
|
2950
|
-
|
|
2951
|
-
|
|
2952
|
-
|
|
2953
|
-
"""
|
|
2954
|
-
:param pulumi.Input[
|
|
2955
|
-
:param pulumi.Input[
|
|
2956
|
-
:param pulumi.Input[
|
|
2957
|
-
:param pulumi.Input[str]
|
|
2958
|
-
:param pulumi.Input[str]
|
|
3214
|
+
grace: pulumi.Input[int],
|
|
3215
|
+
grace_unit: pulumi.Input[str],
|
|
3216
|
+
period: pulumi.Input[int],
|
|
3217
|
+
period_unit: pulumi.Input[str],
|
|
3218
|
+
ping_token: Optional[pulumi.Input[str]] = None):
|
|
3219
|
+
"""
|
|
3220
|
+
:param pulumi.Input[int] grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
3221
|
+
:param pulumi.Input[str] grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
3222
|
+
:param pulumi.Input[int] period: How often you expect a ping to the ping URL.
|
|
3223
|
+
:param pulumi.Input[str] period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
3224
|
+
:param pulumi.Input[str] ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
3225
|
+
"""
|
|
3226
|
+
pulumi.set(__self__, "grace", grace)
|
|
3227
|
+
pulumi.set(__self__, "grace_unit", grace_unit)
|
|
3228
|
+
pulumi.set(__self__, "period", period)
|
|
3229
|
+
pulumi.set(__self__, "period_unit", period_unit)
|
|
3230
|
+
if ping_token is not None:
|
|
3231
|
+
pulumi.set(__self__, "ping_token", ping_token)
|
|
3232
|
+
|
|
3233
|
+
@property
|
|
3234
|
+
@pulumi.getter
|
|
3235
|
+
def grace(self) -> pulumi.Input[int]:
|
|
3236
|
+
"""
|
|
3237
|
+
How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
3238
|
+
"""
|
|
3239
|
+
return pulumi.get(self, "grace")
|
|
3240
|
+
|
|
3241
|
+
@grace.setter
|
|
3242
|
+
def grace(self, value: pulumi.Input[int]):
|
|
3243
|
+
pulumi.set(self, "grace", value)
|
|
3244
|
+
|
|
3245
|
+
@property
|
|
3246
|
+
@pulumi.getter(name="graceUnit")
|
|
3247
|
+
def grace_unit(self) -> pulumi.Input[str]:
|
|
3248
|
+
"""
|
|
3249
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
3250
|
+
"""
|
|
3251
|
+
return pulumi.get(self, "grace_unit")
|
|
3252
|
+
|
|
3253
|
+
@grace_unit.setter
|
|
3254
|
+
def grace_unit(self, value: pulumi.Input[str]):
|
|
3255
|
+
pulumi.set(self, "grace_unit", value)
|
|
3256
|
+
|
|
3257
|
+
@property
|
|
3258
|
+
@pulumi.getter
|
|
3259
|
+
def period(self) -> pulumi.Input[int]:
|
|
3260
|
+
"""
|
|
3261
|
+
How often you expect a ping to the ping URL.
|
|
3262
|
+
"""
|
|
3263
|
+
return pulumi.get(self, "period")
|
|
3264
|
+
|
|
3265
|
+
@period.setter
|
|
3266
|
+
def period(self, value: pulumi.Input[int]):
|
|
3267
|
+
pulumi.set(self, "period", value)
|
|
3268
|
+
|
|
3269
|
+
@property
|
|
3270
|
+
@pulumi.getter(name="periodUnit")
|
|
3271
|
+
def period_unit(self) -> pulumi.Input[str]:
|
|
3272
|
+
"""
|
|
3273
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
3274
|
+
"""
|
|
3275
|
+
return pulumi.get(self, "period_unit")
|
|
3276
|
+
|
|
3277
|
+
@period_unit.setter
|
|
3278
|
+
def period_unit(self, value: pulumi.Input[str]):
|
|
3279
|
+
pulumi.set(self, "period_unit", value)
|
|
3280
|
+
|
|
3281
|
+
@property
|
|
3282
|
+
@pulumi.getter(name="pingToken")
|
|
3283
|
+
def ping_token(self) -> Optional[pulumi.Input[str]]:
|
|
3284
|
+
"""
|
|
3285
|
+
Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
3286
|
+
"""
|
|
3287
|
+
return pulumi.get(self, "ping_token")
|
|
3288
|
+
|
|
3289
|
+
@ping_token.setter
|
|
3290
|
+
def ping_token(self, value: Optional[pulumi.Input[str]]):
|
|
3291
|
+
pulumi.set(self, "ping_token", value)
|
|
3292
|
+
|
|
3293
|
+
|
|
3294
|
+
if not MYPY:
|
|
3295
|
+
class HeartbeatMonitorTriggerIncidentArgsDict(TypedDict):
|
|
3296
|
+
description: pulumi.Input[str]
|
|
3297
|
+
"""
|
|
3298
|
+
A detailed description of the incident.
|
|
3299
|
+
"""
|
|
3300
|
+
name: pulumi.Input[str]
|
|
3301
|
+
"""
|
|
3302
|
+
The name of the incident.
|
|
3303
|
+
"""
|
|
3304
|
+
notify_subscribers: pulumi.Input[bool]
|
|
3305
|
+
"""
|
|
3306
|
+
Whether to notify subscribers when the incident is triggered.
|
|
3307
|
+
"""
|
|
3308
|
+
service_id: pulumi.Input[str]
|
|
3309
|
+
"""
|
|
3310
|
+
The status page service that this incident will be associated with.
|
|
3311
|
+
"""
|
|
3312
|
+
severity: pulumi.Input[str]
|
|
3313
|
+
"""
|
|
3314
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
3315
|
+
"""
|
|
3316
|
+
elif False:
|
|
3317
|
+
HeartbeatMonitorTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
3318
|
+
|
|
3319
|
+
@pulumi.input_type
|
|
3320
|
+
class HeartbeatMonitorTriggerIncidentArgs:
|
|
3321
|
+
def __init__(__self__, *,
|
|
3322
|
+
description: pulumi.Input[str],
|
|
3323
|
+
name: pulumi.Input[str],
|
|
3324
|
+
notify_subscribers: pulumi.Input[bool],
|
|
3325
|
+
service_id: pulumi.Input[str],
|
|
3326
|
+
severity: pulumi.Input[str]):
|
|
3327
|
+
"""
|
|
3328
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
3329
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
3330
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
3331
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
3332
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
3333
|
+
"""
|
|
3334
|
+
pulumi.set(__self__, "description", description)
|
|
3335
|
+
pulumi.set(__self__, "name", name)
|
|
3336
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
3337
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
3338
|
+
pulumi.set(__self__, "severity", severity)
|
|
3339
|
+
|
|
3340
|
+
@property
|
|
3341
|
+
@pulumi.getter
|
|
3342
|
+
def description(self) -> pulumi.Input[str]:
|
|
3343
|
+
"""
|
|
3344
|
+
A detailed description of the incident.
|
|
3345
|
+
"""
|
|
3346
|
+
return pulumi.get(self, "description")
|
|
3347
|
+
|
|
3348
|
+
@description.setter
|
|
3349
|
+
def description(self, value: pulumi.Input[str]):
|
|
3350
|
+
pulumi.set(self, "description", value)
|
|
3351
|
+
|
|
3352
|
+
@property
|
|
3353
|
+
@pulumi.getter
|
|
3354
|
+
def name(self) -> pulumi.Input[str]:
|
|
3355
|
+
"""
|
|
3356
|
+
The name of the incident.
|
|
3357
|
+
"""
|
|
3358
|
+
return pulumi.get(self, "name")
|
|
3359
|
+
|
|
3360
|
+
@name.setter
|
|
3361
|
+
def name(self, value: pulumi.Input[str]):
|
|
3362
|
+
pulumi.set(self, "name", value)
|
|
3363
|
+
|
|
3364
|
+
@property
|
|
3365
|
+
@pulumi.getter(name="notifySubscribers")
|
|
3366
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
3367
|
+
"""
|
|
3368
|
+
Whether to notify subscribers when the incident is triggered.
|
|
3369
|
+
"""
|
|
3370
|
+
return pulumi.get(self, "notify_subscribers")
|
|
3371
|
+
|
|
3372
|
+
@notify_subscribers.setter
|
|
3373
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
3374
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
3375
|
+
|
|
3376
|
+
@property
|
|
3377
|
+
@pulumi.getter(name="serviceId")
|
|
3378
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
3379
|
+
"""
|
|
3380
|
+
The status page service that this incident will be associated with.
|
|
3381
|
+
"""
|
|
3382
|
+
return pulumi.get(self, "service_id")
|
|
3383
|
+
|
|
3384
|
+
@service_id.setter
|
|
3385
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
3386
|
+
pulumi.set(self, "service_id", value)
|
|
3387
|
+
|
|
3388
|
+
@property
|
|
3389
|
+
@pulumi.getter
|
|
3390
|
+
def severity(self) -> pulumi.Input[str]:
|
|
3391
|
+
"""
|
|
3392
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
3393
|
+
"""
|
|
3394
|
+
return pulumi.get(self, "severity")
|
|
3395
|
+
|
|
3396
|
+
@severity.setter
|
|
3397
|
+
def severity(self, value: pulumi.Input[str]):
|
|
3398
|
+
pulumi.set(self, "severity", value)
|
|
3399
|
+
|
|
3400
|
+
|
|
3401
|
+
if not MYPY:
|
|
3402
|
+
class StatusPageCardArgsDict(TypedDict):
|
|
3403
|
+
name: pulumi.Input[str]
|
|
3404
|
+
"""
|
|
3405
|
+
The name of the card.
|
|
3406
|
+
"""
|
|
3407
|
+
service_attachments: pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgsDict']]]
|
|
3408
|
+
"""
|
|
3409
|
+
A list of services to attach to the card.
|
|
3410
|
+
"""
|
|
3411
|
+
elif False:
|
|
3412
|
+
StatusPageCardArgsDict: TypeAlias = Mapping[str, Any]
|
|
3413
|
+
|
|
3414
|
+
@pulumi.input_type
|
|
3415
|
+
class StatusPageCardArgs:
|
|
3416
|
+
def __init__(__self__, *,
|
|
3417
|
+
name: pulumi.Input[str],
|
|
3418
|
+
service_attachments: pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgs']]]):
|
|
3419
|
+
"""
|
|
3420
|
+
:param pulumi.Input[str] name: The name of the card.
|
|
3421
|
+
:param pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgs']]] service_attachments: A list of services to attach to the card.
|
|
3422
|
+
"""
|
|
3423
|
+
pulumi.set(__self__, "name", name)
|
|
3424
|
+
pulumi.set(__self__, "service_attachments", service_attachments)
|
|
3425
|
+
|
|
3426
|
+
@property
|
|
3427
|
+
@pulumi.getter
|
|
3428
|
+
def name(self) -> pulumi.Input[str]:
|
|
3429
|
+
"""
|
|
3430
|
+
The name of the card.
|
|
3431
|
+
"""
|
|
3432
|
+
return pulumi.get(self, "name")
|
|
3433
|
+
|
|
3434
|
+
@name.setter
|
|
3435
|
+
def name(self, value: pulumi.Input[str]):
|
|
3436
|
+
pulumi.set(self, "name", value)
|
|
3437
|
+
|
|
3438
|
+
@property
|
|
3439
|
+
@pulumi.getter(name="serviceAttachments")
|
|
3440
|
+
def service_attachments(self) -> pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgs']]]:
|
|
3441
|
+
"""
|
|
3442
|
+
A list of services to attach to the card.
|
|
3443
|
+
"""
|
|
3444
|
+
return pulumi.get(self, "service_attachments")
|
|
3445
|
+
|
|
3446
|
+
@service_attachments.setter
|
|
3447
|
+
def service_attachments(self, value: pulumi.Input[Sequence[pulumi.Input['StatusPageCardServiceAttachmentArgs']]]):
|
|
3448
|
+
pulumi.set(self, "service_attachments", value)
|
|
3449
|
+
|
|
3450
|
+
|
|
3451
|
+
if not MYPY:
|
|
3452
|
+
class StatusPageCardServiceAttachmentArgsDict(TypedDict):
|
|
3453
|
+
service_id: pulumi.Input[str]
|
|
3454
|
+
"""
|
|
3455
|
+
The ID of the service.
|
|
3456
|
+
"""
|
|
3457
|
+
elif False:
|
|
3458
|
+
StatusPageCardServiceAttachmentArgsDict: TypeAlias = Mapping[str, Any]
|
|
3459
|
+
|
|
3460
|
+
@pulumi.input_type
|
|
3461
|
+
class StatusPageCardServiceAttachmentArgs:
|
|
3462
|
+
def __init__(__self__, *,
|
|
3463
|
+
service_id: pulumi.Input[str]):
|
|
3464
|
+
"""
|
|
3465
|
+
:param pulumi.Input[str] service_id: The ID of the service.
|
|
3466
|
+
"""
|
|
3467
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
3468
|
+
|
|
3469
|
+
@property
|
|
3470
|
+
@pulumi.getter(name="serviceId")
|
|
3471
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
3472
|
+
"""
|
|
3473
|
+
The ID of the service.
|
|
3474
|
+
"""
|
|
3475
|
+
return pulumi.get(self, "service_id")
|
|
3476
|
+
|
|
3477
|
+
@service_id.setter
|
|
3478
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
3479
|
+
pulumi.set(self, "service_id", value)
|
|
3480
|
+
|
|
3481
|
+
|
|
3482
|
+
if not MYPY:
|
|
3483
|
+
class TcpCheckAlertChannelSubscriptionArgsDict(TypedDict):
|
|
3484
|
+
activated: pulumi.Input[bool]
|
|
3485
|
+
channel_id: pulumi.Input[int]
|
|
3486
|
+
elif False:
|
|
3487
|
+
TcpCheckAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
3488
|
+
|
|
3489
|
+
@pulumi.input_type
|
|
3490
|
+
class TcpCheckAlertChannelSubscriptionArgs:
|
|
3491
|
+
def __init__(__self__, *,
|
|
3492
|
+
activated: pulumi.Input[bool],
|
|
3493
|
+
channel_id: pulumi.Input[int]):
|
|
3494
|
+
pulumi.set(__self__, "activated", activated)
|
|
3495
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
3496
|
+
|
|
3497
|
+
@property
|
|
3498
|
+
@pulumi.getter
|
|
3499
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
3500
|
+
return pulumi.get(self, "activated")
|
|
3501
|
+
|
|
3502
|
+
@activated.setter
|
|
3503
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
3504
|
+
pulumi.set(self, "activated", value)
|
|
3505
|
+
|
|
3506
|
+
@property
|
|
3507
|
+
@pulumi.getter(name="channelId")
|
|
3508
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
3509
|
+
return pulumi.get(self, "channel_id")
|
|
3510
|
+
|
|
3511
|
+
@channel_id.setter
|
|
3512
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
3513
|
+
pulumi.set(self, "channel_id", value)
|
|
3514
|
+
|
|
3515
|
+
|
|
3516
|
+
if not MYPY:
|
|
3517
|
+
class TcpCheckAlertSettingsArgsDict(TypedDict):
|
|
3518
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
3519
|
+
"""
|
|
3520
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
3521
|
+
"""
|
|
3522
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
3523
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgsDict']]]]
|
|
3524
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
3525
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
3526
|
+
elif False:
|
|
3527
|
+
TcpCheckAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3528
|
+
|
|
3529
|
+
@pulumi.input_type
|
|
3530
|
+
class TcpCheckAlertSettingsArgs:
|
|
3531
|
+
def __init__(__self__, *,
|
|
3532
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
3533
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
3534
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]] = None,
|
|
3535
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
3536
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
3537
|
+
"""
|
|
3538
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
3539
|
+
"""
|
|
3540
|
+
if escalation_type is not None:
|
|
3541
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
3542
|
+
if parallel_run_failure_thresholds is not None:
|
|
3543
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
3544
|
+
if reminders is not None:
|
|
3545
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
3546
|
+
if run_based_escalations is not None:
|
|
3547
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
3548
|
+
if time_based_escalations is not None:
|
|
3549
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
3550
|
+
|
|
3551
|
+
@property
|
|
3552
|
+
@pulumi.getter(name="escalationType")
|
|
3553
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
3554
|
+
"""
|
|
3555
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
3556
|
+
"""
|
|
3557
|
+
return pulumi.get(self, "escalation_type")
|
|
3558
|
+
|
|
3559
|
+
@escalation_type.setter
|
|
3560
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
3561
|
+
pulumi.set(self, "escalation_type", value)
|
|
3562
|
+
|
|
3563
|
+
@property
|
|
3564
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
3565
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
3566
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
3567
|
+
|
|
3568
|
+
@parallel_run_failure_thresholds.setter
|
|
3569
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
3570
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
3571
|
+
|
|
3572
|
+
@property
|
|
3573
|
+
@pulumi.getter
|
|
3574
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]]:
|
|
3575
|
+
return pulumi.get(self, "reminders")
|
|
3576
|
+
|
|
3577
|
+
@reminders.setter
|
|
3578
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]]):
|
|
3579
|
+
pulumi.set(self, "reminders", value)
|
|
3580
|
+
|
|
3581
|
+
@property
|
|
3582
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
3583
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]]:
|
|
3584
|
+
return pulumi.get(self, "run_based_escalations")
|
|
3585
|
+
|
|
3586
|
+
@run_based_escalations.setter
|
|
3587
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]]):
|
|
3588
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
3589
|
+
|
|
3590
|
+
@property
|
|
3591
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
3592
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
3593
|
+
return pulumi.get(self, "time_based_escalations")
|
|
3594
|
+
|
|
3595
|
+
@time_based_escalations.setter
|
|
3596
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
3597
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
3598
|
+
|
|
3599
|
+
|
|
3600
|
+
if not MYPY:
|
|
3601
|
+
class TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
3602
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
3603
|
+
"""
|
|
3604
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
3605
|
+
"""
|
|
3606
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
3607
|
+
"""
|
|
3608
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
3609
|
+
"""
|
|
3610
|
+
elif False:
|
|
3611
|
+
TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
3612
|
+
|
|
3613
|
+
@pulumi.input_type
|
|
3614
|
+
class TcpCheckAlertSettingsParallelRunFailureThresholdArgs:
|
|
3615
|
+
def __init__(__self__, *,
|
|
3616
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
3617
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
3618
|
+
"""
|
|
3619
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
3620
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
3621
|
+
"""
|
|
3622
|
+
if enabled is not None:
|
|
3623
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
3624
|
+
if percentage is not None:
|
|
3625
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
3626
|
+
|
|
3627
|
+
@property
|
|
3628
|
+
@pulumi.getter
|
|
3629
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
3630
|
+
"""
|
|
3631
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
3632
|
+
"""
|
|
3633
|
+
return pulumi.get(self, "enabled")
|
|
3634
|
+
|
|
3635
|
+
@enabled.setter
|
|
3636
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
3637
|
+
pulumi.set(self, "enabled", value)
|
|
3638
|
+
|
|
3639
|
+
@property
|
|
3640
|
+
@pulumi.getter
|
|
3641
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
3642
|
+
"""
|
|
3643
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
3644
|
+
"""
|
|
3645
|
+
return pulumi.get(self, "percentage")
|
|
3646
|
+
|
|
3647
|
+
@percentage.setter
|
|
3648
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
3649
|
+
pulumi.set(self, "percentage", value)
|
|
3650
|
+
|
|
3651
|
+
|
|
3652
|
+
if not MYPY:
|
|
3653
|
+
class TcpCheckAlertSettingsReminderArgsDict(TypedDict):
|
|
3654
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
3655
|
+
"""
|
|
3656
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
3657
|
+
"""
|
|
3658
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
3659
|
+
"""
|
|
3660
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3661
|
+
"""
|
|
3662
|
+
elif False:
|
|
3663
|
+
TcpCheckAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
3664
|
+
|
|
3665
|
+
@pulumi.input_type
|
|
3666
|
+
class TcpCheckAlertSettingsReminderArgs:
|
|
3667
|
+
def __init__(__self__, *,
|
|
3668
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
3669
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
3670
|
+
"""
|
|
3671
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
3672
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3673
|
+
"""
|
|
3674
|
+
if amount is not None:
|
|
3675
|
+
pulumi.set(__self__, "amount", amount)
|
|
3676
|
+
if interval is not None:
|
|
3677
|
+
pulumi.set(__self__, "interval", interval)
|
|
3678
|
+
|
|
3679
|
+
@property
|
|
3680
|
+
@pulumi.getter
|
|
3681
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
3682
|
+
"""
|
|
3683
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
3684
|
+
"""
|
|
3685
|
+
return pulumi.get(self, "amount")
|
|
3686
|
+
|
|
3687
|
+
@amount.setter
|
|
3688
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
3689
|
+
pulumi.set(self, "amount", value)
|
|
3690
|
+
|
|
3691
|
+
@property
|
|
3692
|
+
@pulumi.getter
|
|
3693
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
3694
|
+
"""
|
|
3695
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3696
|
+
"""
|
|
3697
|
+
return pulumi.get(self, "interval")
|
|
3698
|
+
|
|
3699
|
+
@interval.setter
|
|
3700
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
3701
|
+
pulumi.set(self, "interval", value)
|
|
3702
|
+
|
|
3703
|
+
|
|
3704
|
+
if not MYPY:
|
|
3705
|
+
class TcpCheckAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
3706
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
3707
|
+
"""
|
|
3708
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
3709
|
+
"""
|
|
3710
|
+
elif False:
|
|
3711
|
+
TcpCheckAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3712
|
+
|
|
3713
|
+
@pulumi.input_type
|
|
3714
|
+
class TcpCheckAlertSettingsRunBasedEscalationArgs:
|
|
3715
|
+
def __init__(__self__, *,
|
|
3716
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
3717
|
+
"""
|
|
3718
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
3719
|
+
"""
|
|
3720
|
+
if failed_run_threshold is not None:
|
|
3721
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
3722
|
+
|
|
3723
|
+
@property
|
|
3724
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
3725
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
3726
|
+
"""
|
|
3727
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
3728
|
+
"""
|
|
3729
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
3730
|
+
|
|
3731
|
+
@failed_run_threshold.setter
|
|
3732
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
3733
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
3734
|
+
|
|
3735
|
+
|
|
3736
|
+
if not MYPY:
|
|
3737
|
+
class TcpCheckAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
3738
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
3739
|
+
"""
|
|
3740
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3741
|
+
"""
|
|
3742
|
+
elif False:
|
|
3743
|
+
TcpCheckAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3744
|
+
|
|
3745
|
+
@pulumi.input_type
|
|
3746
|
+
class TcpCheckAlertSettingsTimeBasedEscalationArgs:
|
|
3747
|
+
def __init__(__self__, *,
|
|
3748
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
3749
|
+
"""
|
|
3750
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3751
|
+
"""
|
|
3752
|
+
if minutes_failing_threshold is not None:
|
|
3753
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
3754
|
+
|
|
3755
|
+
@property
|
|
3756
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
3757
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
3758
|
+
"""
|
|
3759
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
3760
|
+
"""
|
|
3761
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
3762
|
+
|
|
3763
|
+
@minutes_failing_threshold.setter
|
|
3764
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
3765
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
3766
|
+
|
|
3767
|
+
|
|
3768
|
+
if not MYPY:
|
|
3769
|
+
class TcpCheckRequestArgsDict(TypedDict):
|
|
3770
|
+
hostname: pulumi.Input[str]
|
|
3771
|
+
"""
|
|
3772
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
3773
|
+
"""
|
|
3774
|
+
port: pulumi.Input[int]
|
|
3775
|
+
"""
|
|
3776
|
+
The port number to connect to.
|
|
3777
|
+
"""
|
|
3778
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgsDict']]]]
|
|
3779
|
+
"""
|
|
3780
|
+
A request can have multiple assertions.
|
|
3781
|
+
"""
|
|
3782
|
+
data: NotRequired[pulumi.Input[str]]
|
|
3783
|
+
"""
|
|
3784
|
+
The data to send to the target host.
|
|
3785
|
+
"""
|
|
3786
|
+
ip_family: NotRequired[pulumi.Input[str]]
|
|
3787
|
+
"""
|
|
3788
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
3789
|
+
"""
|
|
3790
|
+
elif False:
|
|
3791
|
+
TcpCheckRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
3792
|
+
|
|
3793
|
+
@pulumi.input_type
|
|
3794
|
+
class TcpCheckRequestArgs:
|
|
3795
|
+
def __init__(__self__, *,
|
|
3796
|
+
hostname: pulumi.Input[str],
|
|
3797
|
+
port: pulumi.Input[int],
|
|
3798
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]] = None,
|
|
3799
|
+
data: Optional[pulumi.Input[str]] = None,
|
|
3800
|
+
ip_family: Optional[pulumi.Input[str]] = None):
|
|
3801
|
+
"""
|
|
3802
|
+
:param pulumi.Input[str] hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
3803
|
+
:param pulumi.Input[int] port: The port number to connect to.
|
|
3804
|
+
:param pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]] assertions: A request can have multiple assertions.
|
|
3805
|
+
:param pulumi.Input[str] data: The data to send to the target host.
|
|
3806
|
+
:param pulumi.Input[str] ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
3807
|
+
"""
|
|
3808
|
+
pulumi.set(__self__, "hostname", hostname)
|
|
3809
|
+
pulumi.set(__self__, "port", port)
|
|
3810
|
+
if assertions is not None:
|
|
3811
|
+
pulumi.set(__self__, "assertions", assertions)
|
|
3812
|
+
if data is not None:
|
|
3813
|
+
pulumi.set(__self__, "data", data)
|
|
3814
|
+
if ip_family is not None:
|
|
3815
|
+
pulumi.set(__self__, "ip_family", ip_family)
|
|
3816
|
+
|
|
3817
|
+
@property
|
|
3818
|
+
@pulumi.getter
|
|
3819
|
+
def hostname(self) -> pulumi.Input[str]:
|
|
3820
|
+
"""
|
|
3821
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
3822
|
+
"""
|
|
3823
|
+
return pulumi.get(self, "hostname")
|
|
3824
|
+
|
|
3825
|
+
@hostname.setter
|
|
3826
|
+
def hostname(self, value: pulumi.Input[str]):
|
|
3827
|
+
pulumi.set(self, "hostname", value)
|
|
3828
|
+
|
|
3829
|
+
@property
|
|
3830
|
+
@pulumi.getter
|
|
3831
|
+
def port(self) -> pulumi.Input[int]:
|
|
3832
|
+
"""
|
|
3833
|
+
The port number to connect to.
|
|
3834
|
+
"""
|
|
3835
|
+
return pulumi.get(self, "port")
|
|
3836
|
+
|
|
3837
|
+
@port.setter
|
|
3838
|
+
def port(self, value: pulumi.Input[int]):
|
|
3839
|
+
pulumi.set(self, "port", value)
|
|
3840
|
+
|
|
3841
|
+
@property
|
|
3842
|
+
@pulumi.getter
|
|
3843
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]]:
|
|
3844
|
+
"""
|
|
3845
|
+
A request can have multiple assertions.
|
|
3846
|
+
"""
|
|
3847
|
+
return pulumi.get(self, "assertions")
|
|
3848
|
+
|
|
3849
|
+
@assertions.setter
|
|
3850
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]]):
|
|
3851
|
+
pulumi.set(self, "assertions", value)
|
|
3852
|
+
|
|
3853
|
+
@property
|
|
3854
|
+
@pulumi.getter
|
|
3855
|
+
def data(self) -> Optional[pulumi.Input[str]]:
|
|
3856
|
+
"""
|
|
3857
|
+
The data to send to the target host.
|
|
3858
|
+
"""
|
|
3859
|
+
return pulumi.get(self, "data")
|
|
3860
|
+
|
|
3861
|
+
@data.setter
|
|
3862
|
+
def data(self, value: Optional[pulumi.Input[str]]):
|
|
3863
|
+
pulumi.set(self, "data", value)
|
|
3864
|
+
|
|
3865
|
+
@property
|
|
3866
|
+
@pulumi.getter(name="ipFamily")
|
|
3867
|
+
def ip_family(self) -> Optional[pulumi.Input[str]]:
|
|
3868
|
+
"""
|
|
3869
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
3870
|
+
"""
|
|
3871
|
+
return pulumi.get(self, "ip_family")
|
|
3872
|
+
|
|
3873
|
+
@ip_family.setter
|
|
3874
|
+
def ip_family(self, value: Optional[pulumi.Input[str]]):
|
|
3875
|
+
pulumi.set(self, "ip_family", value)
|
|
3876
|
+
|
|
3877
|
+
|
|
3878
|
+
if not MYPY:
|
|
3879
|
+
class TcpCheckRequestAssertionArgsDict(TypedDict):
|
|
3880
|
+
comparison: pulumi.Input[str]
|
|
3881
|
+
"""
|
|
3882
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
3883
|
+
"""
|
|
3884
|
+
source: pulumi.Input[str]
|
|
3885
|
+
"""
|
|
3886
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
3887
|
+
"""
|
|
3888
|
+
property: NotRequired[pulumi.Input[str]]
|
|
3889
|
+
target: NotRequired[pulumi.Input[str]]
|
|
3890
|
+
elif False:
|
|
3891
|
+
TcpCheckRequestAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
3892
|
+
|
|
3893
|
+
@pulumi.input_type
|
|
3894
|
+
class TcpCheckRequestAssertionArgs:
|
|
3895
|
+
def __init__(__self__, *,
|
|
3896
|
+
comparison: pulumi.Input[str],
|
|
3897
|
+
source: pulumi.Input[str],
|
|
3898
|
+
property: Optional[pulumi.Input[str]] = None,
|
|
3899
|
+
target: Optional[pulumi.Input[str]] = None):
|
|
3900
|
+
"""
|
|
3901
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
3902
|
+
:param pulumi.Input[str] source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
3903
|
+
"""
|
|
3904
|
+
pulumi.set(__self__, "comparison", comparison)
|
|
3905
|
+
pulumi.set(__self__, "source", source)
|
|
3906
|
+
if property is not None:
|
|
3907
|
+
pulumi.set(__self__, "property", property)
|
|
3908
|
+
if target is not None:
|
|
3909
|
+
pulumi.set(__self__, "target", target)
|
|
3910
|
+
|
|
3911
|
+
@property
|
|
3912
|
+
@pulumi.getter
|
|
3913
|
+
def comparison(self) -> pulumi.Input[str]:
|
|
3914
|
+
"""
|
|
3915
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
3916
|
+
"""
|
|
3917
|
+
return pulumi.get(self, "comparison")
|
|
3918
|
+
|
|
3919
|
+
@comparison.setter
|
|
3920
|
+
def comparison(self, value: pulumi.Input[str]):
|
|
3921
|
+
pulumi.set(self, "comparison", value)
|
|
3922
|
+
|
|
3923
|
+
@property
|
|
3924
|
+
@pulumi.getter
|
|
3925
|
+
def source(self) -> pulumi.Input[str]:
|
|
3926
|
+
"""
|
|
3927
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
3928
|
+
"""
|
|
3929
|
+
return pulumi.get(self, "source")
|
|
3930
|
+
|
|
3931
|
+
@source.setter
|
|
3932
|
+
def source(self, value: pulumi.Input[str]):
|
|
3933
|
+
pulumi.set(self, "source", value)
|
|
3934
|
+
|
|
3935
|
+
@property
|
|
3936
|
+
@pulumi.getter
|
|
3937
|
+
def target(self) -> Optional[pulumi.Input[str]]:
|
|
3938
|
+
return pulumi.get(self, "target")
|
|
3939
|
+
|
|
3940
|
+
@target.setter
|
|
3941
|
+
def target(self, value: Optional[pulumi.Input[str]]):
|
|
3942
|
+
pulumi.set(self, "target", value)
|
|
3943
|
+
|
|
3944
|
+
@property
|
|
3945
|
+
@pulumi.getter
|
|
3946
|
+
def property(self) -> Optional[pulumi.Input[str]]:
|
|
3947
|
+
return pulumi.get(self, "property")
|
|
3948
|
+
|
|
3949
|
+
@property.setter
|
|
3950
|
+
def property(self, value: Optional[pulumi.Input[str]]):
|
|
3951
|
+
pulumi.set(self, "property", value)
|
|
3952
|
+
|
|
3953
|
+
|
|
3954
|
+
if not MYPY:
|
|
3955
|
+
class TcpCheckRetryStrategyArgsDict(TypedDict):
|
|
3956
|
+
type: pulumi.Input[str]
|
|
3957
|
+
"""
|
|
3958
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
3959
|
+
"""
|
|
3960
|
+
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
3961
|
+
"""
|
|
3962
|
+
The number of seconds to wait before the first retry attempt.
|
|
3963
|
+
"""
|
|
3964
|
+
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
3965
|
+
"""
|
|
3966
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
3967
|
+
"""
|
|
3968
|
+
max_retries: NotRequired[pulumi.Input[int]]
|
|
3969
|
+
"""
|
|
3970
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
3971
|
+
"""
|
|
3972
|
+
same_region: NotRequired[pulumi.Input[bool]]
|
|
3973
|
+
"""
|
|
3974
|
+
Whether retries should be run in the same region as the initial check run.
|
|
3975
|
+
"""
|
|
3976
|
+
elif False:
|
|
3977
|
+
TcpCheckRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3978
|
+
|
|
3979
|
+
@pulumi.input_type
|
|
3980
|
+
class TcpCheckRetryStrategyArgs:
|
|
3981
|
+
def __init__(__self__, *,
|
|
3982
|
+
type: pulumi.Input[str],
|
|
3983
|
+
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
3984
|
+
max_duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
3985
|
+
max_retries: Optional[pulumi.Input[int]] = None,
|
|
3986
|
+
same_region: Optional[pulumi.Input[bool]] = None):
|
|
3987
|
+
"""
|
|
3988
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
3989
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
3990
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
3991
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
3992
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial check run.
|
|
3993
|
+
"""
|
|
3994
|
+
pulumi.set(__self__, "type", type)
|
|
3995
|
+
if base_backoff_seconds is not None:
|
|
3996
|
+
pulumi.set(__self__, "base_backoff_seconds", base_backoff_seconds)
|
|
3997
|
+
if max_duration_seconds is not None:
|
|
3998
|
+
pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
|
|
3999
|
+
if max_retries is not None:
|
|
4000
|
+
pulumi.set(__self__, "max_retries", max_retries)
|
|
4001
|
+
if same_region is not None:
|
|
4002
|
+
pulumi.set(__self__, "same_region", same_region)
|
|
4003
|
+
|
|
4004
|
+
@property
|
|
4005
|
+
@pulumi.getter
|
|
4006
|
+
def type(self) -> pulumi.Input[str]:
|
|
4007
|
+
"""
|
|
4008
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
4009
|
+
"""
|
|
4010
|
+
return pulumi.get(self, "type")
|
|
4011
|
+
|
|
4012
|
+
@type.setter
|
|
4013
|
+
def type(self, value: pulumi.Input[str]):
|
|
4014
|
+
pulumi.set(self, "type", value)
|
|
4015
|
+
|
|
4016
|
+
@property
|
|
4017
|
+
@pulumi.getter(name="baseBackoffSeconds")
|
|
4018
|
+
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4019
|
+
"""
|
|
4020
|
+
The number of seconds to wait before the first retry attempt.
|
|
4021
|
+
"""
|
|
4022
|
+
return pulumi.get(self, "base_backoff_seconds")
|
|
4023
|
+
|
|
4024
|
+
@base_backoff_seconds.setter
|
|
4025
|
+
def base_backoff_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4026
|
+
pulumi.set(self, "base_backoff_seconds", value)
|
|
4027
|
+
|
|
4028
|
+
@property
|
|
4029
|
+
@pulumi.getter(name="maxDurationSeconds")
|
|
4030
|
+
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4031
|
+
"""
|
|
4032
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
4033
|
+
"""
|
|
4034
|
+
return pulumi.get(self, "max_duration_seconds")
|
|
4035
|
+
|
|
4036
|
+
@max_duration_seconds.setter
|
|
4037
|
+
def max_duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4038
|
+
pulumi.set(self, "max_duration_seconds", value)
|
|
4039
|
+
|
|
4040
|
+
@property
|
|
4041
|
+
@pulumi.getter(name="maxRetries")
|
|
4042
|
+
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
4043
|
+
"""
|
|
4044
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
4045
|
+
"""
|
|
4046
|
+
return pulumi.get(self, "max_retries")
|
|
4047
|
+
|
|
4048
|
+
@max_retries.setter
|
|
4049
|
+
def max_retries(self, value: Optional[pulumi.Input[int]]):
|
|
4050
|
+
pulumi.set(self, "max_retries", value)
|
|
4051
|
+
|
|
4052
|
+
@property
|
|
4053
|
+
@pulumi.getter(name="sameRegion")
|
|
4054
|
+
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
4055
|
+
"""
|
|
4056
|
+
Whether retries should be run in the same region as the initial check run.
|
|
4057
|
+
"""
|
|
4058
|
+
return pulumi.get(self, "same_region")
|
|
4059
|
+
|
|
4060
|
+
@same_region.setter
|
|
4061
|
+
def same_region(self, value: Optional[pulumi.Input[bool]]):
|
|
4062
|
+
pulumi.set(self, "same_region", value)
|
|
4063
|
+
|
|
4064
|
+
|
|
4065
|
+
if not MYPY:
|
|
4066
|
+
class TcpCheckTriggerIncidentArgsDict(TypedDict):
|
|
4067
|
+
description: pulumi.Input[str]
|
|
4068
|
+
"""
|
|
4069
|
+
A detailed description of the incident.
|
|
4070
|
+
"""
|
|
4071
|
+
name: pulumi.Input[str]
|
|
4072
|
+
"""
|
|
4073
|
+
The name of the incident.
|
|
4074
|
+
"""
|
|
4075
|
+
notify_subscribers: pulumi.Input[bool]
|
|
4076
|
+
"""
|
|
4077
|
+
Whether to notify subscribers when the incident is triggered.
|
|
4078
|
+
"""
|
|
4079
|
+
service_id: pulumi.Input[str]
|
|
4080
|
+
"""
|
|
4081
|
+
The status page service that this incident will be associated with.
|
|
4082
|
+
"""
|
|
4083
|
+
severity: pulumi.Input[str]
|
|
4084
|
+
"""
|
|
4085
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4086
|
+
"""
|
|
4087
|
+
elif False:
|
|
4088
|
+
TcpCheckTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
4089
|
+
|
|
4090
|
+
@pulumi.input_type
|
|
4091
|
+
class TcpCheckTriggerIncidentArgs:
|
|
4092
|
+
def __init__(__self__, *,
|
|
4093
|
+
description: pulumi.Input[str],
|
|
4094
|
+
name: pulumi.Input[str],
|
|
4095
|
+
notify_subscribers: pulumi.Input[bool],
|
|
4096
|
+
service_id: pulumi.Input[str],
|
|
4097
|
+
severity: pulumi.Input[str]):
|
|
4098
|
+
"""
|
|
4099
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
4100
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
4101
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
4102
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
4103
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4104
|
+
"""
|
|
4105
|
+
pulumi.set(__self__, "description", description)
|
|
4106
|
+
pulumi.set(__self__, "name", name)
|
|
4107
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
4108
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
4109
|
+
pulumi.set(__self__, "severity", severity)
|
|
4110
|
+
|
|
4111
|
+
@property
|
|
4112
|
+
@pulumi.getter
|
|
4113
|
+
def description(self) -> pulumi.Input[str]:
|
|
4114
|
+
"""
|
|
4115
|
+
A detailed description of the incident.
|
|
4116
|
+
"""
|
|
4117
|
+
return pulumi.get(self, "description")
|
|
4118
|
+
|
|
4119
|
+
@description.setter
|
|
4120
|
+
def description(self, value: pulumi.Input[str]):
|
|
4121
|
+
pulumi.set(self, "description", value)
|
|
4122
|
+
|
|
4123
|
+
@property
|
|
4124
|
+
@pulumi.getter
|
|
4125
|
+
def name(self) -> pulumi.Input[str]:
|
|
4126
|
+
"""
|
|
4127
|
+
The name of the incident.
|
|
4128
|
+
"""
|
|
4129
|
+
return pulumi.get(self, "name")
|
|
4130
|
+
|
|
4131
|
+
@name.setter
|
|
4132
|
+
def name(self, value: pulumi.Input[str]):
|
|
4133
|
+
pulumi.set(self, "name", value)
|
|
4134
|
+
|
|
4135
|
+
@property
|
|
4136
|
+
@pulumi.getter(name="notifySubscribers")
|
|
4137
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
4138
|
+
"""
|
|
4139
|
+
Whether to notify subscribers when the incident is triggered.
|
|
4140
|
+
"""
|
|
4141
|
+
return pulumi.get(self, "notify_subscribers")
|
|
4142
|
+
|
|
4143
|
+
@notify_subscribers.setter
|
|
4144
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
4145
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
4146
|
+
|
|
4147
|
+
@property
|
|
4148
|
+
@pulumi.getter(name="serviceId")
|
|
4149
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
4150
|
+
"""
|
|
4151
|
+
The status page service that this incident will be associated with.
|
|
4152
|
+
"""
|
|
4153
|
+
return pulumi.get(self, "service_id")
|
|
4154
|
+
|
|
4155
|
+
@service_id.setter
|
|
4156
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
4157
|
+
pulumi.set(self, "service_id", value)
|
|
4158
|
+
|
|
4159
|
+
@property
|
|
4160
|
+
@pulumi.getter
|
|
4161
|
+
def severity(self) -> pulumi.Input[str]:
|
|
4162
|
+
"""
|
|
4163
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4164
|
+
"""
|
|
4165
|
+
return pulumi.get(self, "severity")
|
|
4166
|
+
|
|
4167
|
+
@severity.setter
|
|
4168
|
+
def severity(self, value: pulumi.Input[str]):
|
|
4169
|
+
pulumi.set(self, "severity", value)
|
|
4170
|
+
|
|
4171
|
+
|
|
4172
|
+
if not MYPY:
|
|
4173
|
+
class TcpMonitorAlertChannelSubscriptionArgsDict(TypedDict):
|
|
4174
|
+
activated: pulumi.Input[bool]
|
|
4175
|
+
channel_id: pulumi.Input[int]
|
|
4176
|
+
elif False:
|
|
4177
|
+
TcpMonitorAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
4178
|
+
|
|
4179
|
+
@pulumi.input_type
|
|
4180
|
+
class TcpMonitorAlertChannelSubscriptionArgs:
|
|
4181
|
+
def __init__(__self__, *,
|
|
4182
|
+
activated: pulumi.Input[bool],
|
|
4183
|
+
channel_id: pulumi.Input[int]):
|
|
4184
|
+
pulumi.set(__self__, "activated", activated)
|
|
4185
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
4186
|
+
|
|
4187
|
+
@property
|
|
4188
|
+
@pulumi.getter
|
|
4189
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
4190
|
+
return pulumi.get(self, "activated")
|
|
4191
|
+
|
|
4192
|
+
@activated.setter
|
|
4193
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
4194
|
+
pulumi.set(self, "activated", value)
|
|
4195
|
+
|
|
4196
|
+
@property
|
|
4197
|
+
@pulumi.getter(name="channelId")
|
|
4198
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
4199
|
+
return pulumi.get(self, "channel_id")
|
|
4200
|
+
|
|
4201
|
+
@channel_id.setter
|
|
4202
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
4203
|
+
pulumi.set(self, "channel_id", value)
|
|
4204
|
+
|
|
4205
|
+
|
|
4206
|
+
if not MYPY:
|
|
4207
|
+
class TcpMonitorAlertSettingsArgsDict(TypedDict):
|
|
4208
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
4209
|
+
"""
|
|
4210
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
4211
|
+
"""
|
|
4212
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
4213
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsReminderArgsDict']]]]
|
|
4214
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
4215
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
4216
|
+
elif False:
|
|
4217
|
+
TcpMonitorAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4218
|
+
|
|
4219
|
+
@pulumi.input_type
|
|
4220
|
+
class TcpMonitorAlertSettingsArgs:
|
|
4221
|
+
def __init__(__self__, *,
|
|
4222
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
4223
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
4224
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsReminderArgs']]]] = None,
|
|
4225
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
4226
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
4227
|
+
"""
|
|
4228
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
4229
|
+
"""
|
|
4230
|
+
if escalation_type is not None:
|
|
4231
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
4232
|
+
if parallel_run_failure_thresholds is not None:
|
|
4233
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
4234
|
+
if reminders is not None:
|
|
4235
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
4236
|
+
if run_based_escalations is not None:
|
|
4237
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
4238
|
+
if time_based_escalations is not None:
|
|
4239
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
4240
|
+
|
|
4241
|
+
@property
|
|
4242
|
+
@pulumi.getter(name="escalationType")
|
|
4243
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
4244
|
+
"""
|
|
4245
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
4246
|
+
"""
|
|
4247
|
+
return pulumi.get(self, "escalation_type")
|
|
4248
|
+
|
|
4249
|
+
@escalation_type.setter
|
|
4250
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
4251
|
+
pulumi.set(self, "escalation_type", value)
|
|
4252
|
+
|
|
4253
|
+
@property
|
|
4254
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
4255
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
4256
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
4257
|
+
|
|
4258
|
+
@parallel_run_failure_thresholds.setter
|
|
4259
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
4260
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
4261
|
+
|
|
4262
|
+
@property
|
|
4263
|
+
@pulumi.getter
|
|
4264
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsReminderArgs']]]]:
|
|
4265
|
+
return pulumi.get(self, "reminders")
|
|
4266
|
+
|
|
4267
|
+
@reminders.setter
|
|
4268
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsReminderArgs']]]]):
|
|
4269
|
+
pulumi.set(self, "reminders", value)
|
|
4270
|
+
|
|
4271
|
+
@property
|
|
4272
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
4273
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsRunBasedEscalationArgs']]]]:
|
|
4274
|
+
return pulumi.get(self, "run_based_escalations")
|
|
4275
|
+
|
|
4276
|
+
@run_based_escalations.setter
|
|
4277
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsRunBasedEscalationArgs']]]]):
|
|
4278
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
4279
|
+
|
|
4280
|
+
@property
|
|
4281
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
4282
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
4283
|
+
return pulumi.get(self, "time_based_escalations")
|
|
4284
|
+
|
|
4285
|
+
@time_based_escalations.setter
|
|
4286
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
4287
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
4288
|
+
|
|
4289
|
+
|
|
4290
|
+
if not MYPY:
|
|
4291
|
+
class TcpMonitorAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
4292
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
4293
|
+
"""
|
|
4294
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
4295
|
+
"""
|
|
4296
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
4297
|
+
"""
|
|
4298
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
4299
|
+
"""
|
|
4300
|
+
elif False:
|
|
4301
|
+
TcpMonitorAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
4302
|
+
|
|
4303
|
+
@pulumi.input_type
|
|
4304
|
+
class TcpMonitorAlertSettingsParallelRunFailureThresholdArgs:
|
|
4305
|
+
def __init__(__self__, *,
|
|
4306
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
4307
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
4308
|
+
"""
|
|
4309
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
4310
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
4311
|
+
"""
|
|
4312
|
+
if enabled is not None:
|
|
4313
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
4314
|
+
if percentage is not None:
|
|
4315
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
4316
|
+
|
|
4317
|
+
@property
|
|
4318
|
+
@pulumi.getter
|
|
4319
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4320
|
+
"""
|
|
4321
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
4322
|
+
"""
|
|
4323
|
+
return pulumi.get(self, "enabled")
|
|
4324
|
+
|
|
4325
|
+
@enabled.setter
|
|
4326
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4327
|
+
pulumi.set(self, "enabled", value)
|
|
4328
|
+
|
|
4329
|
+
@property
|
|
4330
|
+
@pulumi.getter
|
|
4331
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
4332
|
+
"""
|
|
4333
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
4334
|
+
"""
|
|
4335
|
+
return pulumi.get(self, "percentage")
|
|
4336
|
+
|
|
4337
|
+
@percentage.setter
|
|
4338
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
4339
|
+
pulumi.set(self, "percentage", value)
|
|
4340
|
+
|
|
4341
|
+
|
|
4342
|
+
if not MYPY:
|
|
4343
|
+
class TcpMonitorAlertSettingsReminderArgsDict(TypedDict):
|
|
4344
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
4345
|
+
"""
|
|
4346
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
4347
|
+
"""
|
|
4348
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
4349
|
+
"""
|
|
4350
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4351
|
+
"""
|
|
4352
|
+
elif False:
|
|
4353
|
+
TcpMonitorAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
4354
|
+
|
|
4355
|
+
@pulumi.input_type
|
|
4356
|
+
class TcpMonitorAlertSettingsReminderArgs:
|
|
4357
|
+
def __init__(__self__, *,
|
|
4358
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
4359
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
4360
|
+
"""
|
|
4361
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
4362
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4363
|
+
"""
|
|
4364
|
+
if amount is not None:
|
|
4365
|
+
pulumi.set(__self__, "amount", amount)
|
|
4366
|
+
if interval is not None:
|
|
4367
|
+
pulumi.set(__self__, "interval", interval)
|
|
4368
|
+
|
|
4369
|
+
@property
|
|
4370
|
+
@pulumi.getter
|
|
4371
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
4372
|
+
"""
|
|
4373
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
4374
|
+
"""
|
|
4375
|
+
return pulumi.get(self, "amount")
|
|
4376
|
+
|
|
4377
|
+
@amount.setter
|
|
4378
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
4379
|
+
pulumi.set(self, "amount", value)
|
|
4380
|
+
|
|
4381
|
+
@property
|
|
4382
|
+
@pulumi.getter
|
|
4383
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
4384
|
+
"""
|
|
4385
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4386
|
+
"""
|
|
4387
|
+
return pulumi.get(self, "interval")
|
|
4388
|
+
|
|
4389
|
+
@interval.setter
|
|
4390
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
4391
|
+
pulumi.set(self, "interval", value)
|
|
4392
|
+
|
|
4393
|
+
|
|
4394
|
+
if not MYPY:
|
|
4395
|
+
class TcpMonitorAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
4396
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
4397
|
+
"""
|
|
4398
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
4399
|
+
"""
|
|
4400
|
+
elif False:
|
|
4401
|
+
TcpMonitorAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
4402
|
+
|
|
4403
|
+
@pulumi.input_type
|
|
4404
|
+
class TcpMonitorAlertSettingsRunBasedEscalationArgs:
|
|
4405
|
+
def __init__(__self__, *,
|
|
4406
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
4407
|
+
"""
|
|
4408
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
4409
|
+
"""
|
|
4410
|
+
if failed_run_threshold is not None:
|
|
4411
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
4412
|
+
|
|
4413
|
+
@property
|
|
4414
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
4415
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
4416
|
+
"""
|
|
4417
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
4418
|
+
"""
|
|
4419
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
4420
|
+
|
|
4421
|
+
@failed_run_threshold.setter
|
|
4422
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
4423
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
4424
|
+
|
|
4425
|
+
|
|
4426
|
+
if not MYPY:
|
|
4427
|
+
class TcpMonitorAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
4428
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
4429
|
+
"""
|
|
4430
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4431
|
+
"""
|
|
4432
|
+
elif False:
|
|
4433
|
+
TcpMonitorAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
4434
|
+
|
|
4435
|
+
@pulumi.input_type
|
|
4436
|
+
class TcpMonitorAlertSettingsTimeBasedEscalationArgs:
|
|
4437
|
+
def __init__(__self__, *,
|
|
4438
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
4439
|
+
"""
|
|
4440
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4441
|
+
"""
|
|
4442
|
+
if minutes_failing_threshold is not None:
|
|
4443
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
4444
|
+
|
|
4445
|
+
@property
|
|
4446
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
4447
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
4448
|
+
"""
|
|
4449
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
4450
|
+
"""
|
|
4451
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
4452
|
+
|
|
4453
|
+
@minutes_failing_threshold.setter
|
|
4454
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
4455
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
4456
|
+
|
|
4457
|
+
|
|
4458
|
+
if not MYPY:
|
|
4459
|
+
class TcpMonitorRequestArgsDict(TypedDict):
|
|
4460
|
+
hostname: pulumi.Input[str]
|
|
4461
|
+
"""
|
|
4462
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
4463
|
+
"""
|
|
4464
|
+
port: pulumi.Input[int]
|
|
4465
|
+
"""
|
|
4466
|
+
The port number to connect to.
|
|
4467
|
+
"""
|
|
4468
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpMonitorRequestAssertionArgsDict']]]]
|
|
4469
|
+
"""
|
|
4470
|
+
A request can have multiple assertions.
|
|
4471
|
+
"""
|
|
4472
|
+
data: NotRequired[pulumi.Input[str]]
|
|
4473
|
+
"""
|
|
4474
|
+
The data to send to the target host.
|
|
4475
|
+
"""
|
|
4476
|
+
ip_family: NotRequired[pulumi.Input[str]]
|
|
4477
|
+
"""
|
|
4478
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
4479
|
+
"""
|
|
4480
|
+
elif False:
|
|
4481
|
+
TcpMonitorRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
4482
|
+
|
|
4483
|
+
@pulumi.input_type
|
|
4484
|
+
class TcpMonitorRequestArgs:
|
|
4485
|
+
def __init__(__self__, *,
|
|
4486
|
+
hostname: pulumi.Input[str],
|
|
4487
|
+
port: pulumi.Input[int],
|
|
4488
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorRequestAssertionArgs']]]] = None,
|
|
4489
|
+
data: Optional[pulumi.Input[str]] = None,
|
|
4490
|
+
ip_family: Optional[pulumi.Input[str]] = None):
|
|
4491
|
+
"""
|
|
4492
|
+
:param pulumi.Input[str] hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
4493
|
+
:param pulumi.Input[int] port: The port number to connect to.
|
|
4494
|
+
:param pulumi.Input[Sequence[pulumi.Input['TcpMonitorRequestAssertionArgs']]] assertions: A request can have multiple assertions.
|
|
4495
|
+
:param pulumi.Input[str] data: The data to send to the target host.
|
|
4496
|
+
:param pulumi.Input[str] ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
2959
4497
|
"""
|
|
2960
4498
|
pulumi.set(__self__, "hostname", hostname)
|
|
2961
4499
|
pulumi.set(__self__, "port", port)
|
|
@@ -2968,57 +4506,779 @@ class TcpCheckRequestArgs:
|
|
|
2968
4506
|
|
|
2969
4507
|
@property
|
|
2970
4508
|
@pulumi.getter
|
|
2971
|
-
def hostname(self) -> pulumi.Input[str]:
|
|
4509
|
+
def hostname(self) -> pulumi.Input[str]:
|
|
4510
|
+
"""
|
|
4511
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
4512
|
+
"""
|
|
4513
|
+
return pulumi.get(self, "hostname")
|
|
4514
|
+
|
|
4515
|
+
@hostname.setter
|
|
4516
|
+
def hostname(self, value: pulumi.Input[str]):
|
|
4517
|
+
pulumi.set(self, "hostname", value)
|
|
4518
|
+
|
|
4519
|
+
@property
|
|
4520
|
+
@pulumi.getter
|
|
4521
|
+
def port(self) -> pulumi.Input[int]:
|
|
4522
|
+
"""
|
|
4523
|
+
The port number to connect to.
|
|
4524
|
+
"""
|
|
4525
|
+
return pulumi.get(self, "port")
|
|
4526
|
+
|
|
4527
|
+
@port.setter
|
|
4528
|
+
def port(self, value: pulumi.Input[int]):
|
|
4529
|
+
pulumi.set(self, "port", value)
|
|
4530
|
+
|
|
4531
|
+
@property
|
|
4532
|
+
@pulumi.getter
|
|
4533
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorRequestAssertionArgs']]]]:
|
|
4534
|
+
"""
|
|
4535
|
+
A request can have multiple assertions.
|
|
4536
|
+
"""
|
|
4537
|
+
return pulumi.get(self, "assertions")
|
|
4538
|
+
|
|
4539
|
+
@assertions.setter
|
|
4540
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpMonitorRequestAssertionArgs']]]]):
|
|
4541
|
+
pulumi.set(self, "assertions", value)
|
|
4542
|
+
|
|
4543
|
+
@property
|
|
4544
|
+
@pulumi.getter
|
|
4545
|
+
def data(self) -> Optional[pulumi.Input[str]]:
|
|
4546
|
+
"""
|
|
4547
|
+
The data to send to the target host.
|
|
4548
|
+
"""
|
|
4549
|
+
return pulumi.get(self, "data")
|
|
4550
|
+
|
|
4551
|
+
@data.setter
|
|
4552
|
+
def data(self, value: Optional[pulumi.Input[str]]):
|
|
4553
|
+
pulumi.set(self, "data", value)
|
|
4554
|
+
|
|
4555
|
+
@property
|
|
4556
|
+
@pulumi.getter(name="ipFamily")
|
|
4557
|
+
def ip_family(self) -> Optional[pulumi.Input[str]]:
|
|
4558
|
+
"""
|
|
4559
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
4560
|
+
"""
|
|
4561
|
+
return pulumi.get(self, "ip_family")
|
|
4562
|
+
|
|
4563
|
+
@ip_family.setter
|
|
4564
|
+
def ip_family(self, value: Optional[pulumi.Input[str]]):
|
|
4565
|
+
pulumi.set(self, "ip_family", value)
|
|
4566
|
+
|
|
4567
|
+
|
|
4568
|
+
if not MYPY:
|
|
4569
|
+
class TcpMonitorRequestAssertionArgsDict(TypedDict):
|
|
4570
|
+
comparison: pulumi.Input[str]
|
|
4571
|
+
"""
|
|
4572
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
4573
|
+
"""
|
|
4574
|
+
source: pulumi.Input[str]
|
|
4575
|
+
"""
|
|
4576
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
4577
|
+
"""
|
|
4578
|
+
property: NotRequired[pulumi.Input[str]]
|
|
4579
|
+
target: NotRequired[pulumi.Input[str]]
|
|
4580
|
+
elif False:
|
|
4581
|
+
TcpMonitorRequestAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
4582
|
+
|
|
4583
|
+
@pulumi.input_type
|
|
4584
|
+
class TcpMonitorRequestAssertionArgs:
|
|
4585
|
+
def __init__(__self__, *,
|
|
4586
|
+
comparison: pulumi.Input[str],
|
|
4587
|
+
source: pulumi.Input[str],
|
|
4588
|
+
property: Optional[pulumi.Input[str]] = None,
|
|
4589
|
+
target: Optional[pulumi.Input[str]] = None):
|
|
4590
|
+
"""
|
|
4591
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
4592
|
+
:param pulumi.Input[str] source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
4593
|
+
"""
|
|
4594
|
+
pulumi.set(__self__, "comparison", comparison)
|
|
4595
|
+
pulumi.set(__self__, "source", source)
|
|
4596
|
+
if property is not None:
|
|
4597
|
+
pulumi.set(__self__, "property", property)
|
|
4598
|
+
if target is not None:
|
|
4599
|
+
pulumi.set(__self__, "target", target)
|
|
4600
|
+
|
|
4601
|
+
@property
|
|
4602
|
+
@pulumi.getter
|
|
4603
|
+
def comparison(self) -> pulumi.Input[str]:
|
|
4604
|
+
"""
|
|
4605
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
4606
|
+
"""
|
|
4607
|
+
return pulumi.get(self, "comparison")
|
|
4608
|
+
|
|
4609
|
+
@comparison.setter
|
|
4610
|
+
def comparison(self, value: pulumi.Input[str]):
|
|
4611
|
+
pulumi.set(self, "comparison", value)
|
|
4612
|
+
|
|
4613
|
+
@property
|
|
4614
|
+
@pulumi.getter
|
|
4615
|
+
def source(self) -> pulumi.Input[str]:
|
|
4616
|
+
"""
|
|
4617
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
4618
|
+
"""
|
|
4619
|
+
return pulumi.get(self, "source")
|
|
4620
|
+
|
|
4621
|
+
@source.setter
|
|
4622
|
+
def source(self, value: pulumi.Input[str]):
|
|
4623
|
+
pulumi.set(self, "source", value)
|
|
4624
|
+
|
|
4625
|
+
@property
|
|
4626
|
+
@pulumi.getter
|
|
4627
|
+
def target(self) -> Optional[pulumi.Input[str]]:
|
|
4628
|
+
return pulumi.get(self, "target")
|
|
4629
|
+
|
|
4630
|
+
@target.setter
|
|
4631
|
+
def target(self, value: Optional[pulumi.Input[str]]):
|
|
4632
|
+
pulumi.set(self, "target", value)
|
|
4633
|
+
|
|
4634
|
+
@property
|
|
4635
|
+
@pulumi.getter
|
|
4636
|
+
def property(self) -> Optional[pulumi.Input[str]]:
|
|
4637
|
+
return pulumi.get(self, "property")
|
|
4638
|
+
|
|
4639
|
+
@property.setter
|
|
4640
|
+
def property(self, value: Optional[pulumi.Input[str]]):
|
|
4641
|
+
pulumi.set(self, "property", value)
|
|
4642
|
+
|
|
4643
|
+
|
|
4644
|
+
if not MYPY:
|
|
4645
|
+
class TcpMonitorRetryStrategyArgsDict(TypedDict):
|
|
4646
|
+
type: pulumi.Input[str]
|
|
4647
|
+
"""
|
|
4648
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
4649
|
+
"""
|
|
4650
|
+
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
4651
|
+
"""
|
|
4652
|
+
The number of seconds to wait before the first retry attempt.
|
|
4653
|
+
"""
|
|
4654
|
+
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
4655
|
+
"""
|
|
4656
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
4657
|
+
"""
|
|
4658
|
+
max_retries: NotRequired[pulumi.Input[int]]
|
|
4659
|
+
"""
|
|
4660
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
4661
|
+
"""
|
|
4662
|
+
same_region: NotRequired[pulumi.Input[bool]]
|
|
4663
|
+
"""
|
|
4664
|
+
Whether retries should be run in the same region as the initial check run.
|
|
4665
|
+
"""
|
|
4666
|
+
elif False:
|
|
4667
|
+
TcpMonitorRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
4668
|
+
|
|
4669
|
+
@pulumi.input_type
|
|
4670
|
+
class TcpMonitorRetryStrategyArgs:
|
|
4671
|
+
def __init__(__self__, *,
|
|
4672
|
+
type: pulumi.Input[str],
|
|
4673
|
+
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
4674
|
+
max_duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
4675
|
+
max_retries: Optional[pulumi.Input[int]] = None,
|
|
4676
|
+
same_region: Optional[pulumi.Input[bool]] = None):
|
|
4677
|
+
"""
|
|
4678
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
4679
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
4680
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
4681
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
4682
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial check run.
|
|
4683
|
+
"""
|
|
4684
|
+
pulumi.set(__self__, "type", type)
|
|
4685
|
+
if base_backoff_seconds is not None:
|
|
4686
|
+
pulumi.set(__self__, "base_backoff_seconds", base_backoff_seconds)
|
|
4687
|
+
if max_duration_seconds is not None:
|
|
4688
|
+
pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
|
|
4689
|
+
if max_retries is not None:
|
|
4690
|
+
pulumi.set(__self__, "max_retries", max_retries)
|
|
4691
|
+
if same_region is not None:
|
|
4692
|
+
pulumi.set(__self__, "same_region", same_region)
|
|
4693
|
+
|
|
4694
|
+
@property
|
|
4695
|
+
@pulumi.getter
|
|
4696
|
+
def type(self) -> pulumi.Input[str]:
|
|
4697
|
+
"""
|
|
4698
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
4699
|
+
"""
|
|
4700
|
+
return pulumi.get(self, "type")
|
|
4701
|
+
|
|
4702
|
+
@type.setter
|
|
4703
|
+
def type(self, value: pulumi.Input[str]):
|
|
4704
|
+
pulumi.set(self, "type", value)
|
|
4705
|
+
|
|
4706
|
+
@property
|
|
4707
|
+
@pulumi.getter(name="baseBackoffSeconds")
|
|
4708
|
+
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4709
|
+
"""
|
|
4710
|
+
The number of seconds to wait before the first retry attempt.
|
|
4711
|
+
"""
|
|
4712
|
+
return pulumi.get(self, "base_backoff_seconds")
|
|
4713
|
+
|
|
4714
|
+
@base_backoff_seconds.setter
|
|
4715
|
+
def base_backoff_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4716
|
+
pulumi.set(self, "base_backoff_seconds", value)
|
|
4717
|
+
|
|
4718
|
+
@property
|
|
4719
|
+
@pulumi.getter(name="maxDurationSeconds")
|
|
4720
|
+
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4721
|
+
"""
|
|
4722
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
4723
|
+
"""
|
|
4724
|
+
return pulumi.get(self, "max_duration_seconds")
|
|
4725
|
+
|
|
4726
|
+
@max_duration_seconds.setter
|
|
4727
|
+
def max_duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4728
|
+
pulumi.set(self, "max_duration_seconds", value)
|
|
4729
|
+
|
|
4730
|
+
@property
|
|
4731
|
+
@pulumi.getter(name="maxRetries")
|
|
4732
|
+
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
4733
|
+
"""
|
|
4734
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
4735
|
+
"""
|
|
4736
|
+
return pulumi.get(self, "max_retries")
|
|
4737
|
+
|
|
4738
|
+
@max_retries.setter
|
|
4739
|
+
def max_retries(self, value: Optional[pulumi.Input[int]]):
|
|
4740
|
+
pulumi.set(self, "max_retries", value)
|
|
4741
|
+
|
|
4742
|
+
@property
|
|
4743
|
+
@pulumi.getter(name="sameRegion")
|
|
4744
|
+
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
4745
|
+
"""
|
|
4746
|
+
Whether retries should be run in the same region as the initial check run.
|
|
4747
|
+
"""
|
|
4748
|
+
return pulumi.get(self, "same_region")
|
|
4749
|
+
|
|
4750
|
+
@same_region.setter
|
|
4751
|
+
def same_region(self, value: Optional[pulumi.Input[bool]]):
|
|
4752
|
+
pulumi.set(self, "same_region", value)
|
|
4753
|
+
|
|
4754
|
+
|
|
4755
|
+
if not MYPY:
|
|
4756
|
+
class TcpMonitorTriggerIncidentArgsDict(TypedDict):
|
|
4757
|
+
description: pulumi.Input[str]
|
|
4758
|
+
"""
|
|
4759
|
+
A detailed description of the incident.
|
|
4760
|
+
"""
|
|
4761
|
+
name: pulumi.Input[str]
|
|
4762
|
+
"""
|
|
4763
|
+
The name of the incident.
|
|
4764
|
+
"""
|
|
4765
|
+
notify_subscribers: pulumi.Input[bool]
|
|
4766
|
+
"""
|
|
4767
|
+
Whether to notify subscribers when the incident is triggered.
|
|
4768
|
+
"""
|
|
4769
|
+
service_id: pulumi.Input[str]
|
|
4770
|
+
"""
|
|
4771
|
+
The status page service that this incident will be associated with.
|
|
4772
|
+
"""
|
|
4773
|
+
severity: pulumi.Input[str]
|
|
4774
|
+
"""
|
|
4775
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4776
|
+
"""
|
|
4777
|
+
elif False:
|
|
4778
|
+
TcpMonitorTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
4779
|
+
|
|
4780
|
+
@pulumi.input_type
|
|
4781
|
+
class TcpMonitorTriggerIncidentArgs:
|
|
4782
|
+
def __init__(__self__, *,
|
|
4783
|
+
description: pulumi.Input[str],
|
|
4784
|
+
name: pulumi.Input[str],
|
|
4785
|
+
notify_subscribers: pulumi.Input[bool],
|
|
4786
|
+
service_id: pulumi.Input[str],
|
|
4787
|
+
severity: pulumi.Input[str]):
|
|
4788
|
+
"""
|
|
4789
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
4790
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
4791
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
4792
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
4793
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4794
|
+
"""
|
|
4795
|
+
pulumi.set(__self__, "description", description)
|
|
4796
|
+
pulumi.set(__self__, "name", name)
|
|
4797
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
4798
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
4799
|
+
pulumi.set(__self__, "severity", severity)
|
|
4800
|
+
|
|
4801
|
+
@property
|
|
4802
|
+
@pulumi.getter
|
|
4803
|
+
def description(self) -> pulumi.Input[str]:
|
|
4804
|
+
"""
|
|
4805
|
+
A detailed description of the incident.
|
|
4806
|
+
"""
|
|
4807
|
+
return pulumi.get(self, "description")
|
|
4808
|
+
|
|
4809
|
+
@description.setter
|
|
4810
|
+
def description(self, value: pulumi.Input[str]):
|
|
4811
|
+
pulumi.set(self, "description", value)
|
|
4812
|
+
|
|
4813
|
+
@property
|
|
4814
|
+
@pulumi.getter
|
|
4815
|
+
def name(self) -> pulumi.Input[str]:
|
|
4816
|
+
"""
|
|
4817
|
+
The name of the incident.
|
|
4818
|
+
"""
|
|
4819
|
+
return pulumi.get(self, "name")
|
|
4820
|
+
|
|
4821
|
+
@name.setter
|
|
4822
|
+
def name(self, value: pulumi.Input[str]):
|
|
4823
|
+
pulumi.set(self, "name", value)
|
|
4824
|
+
|
|
4825
|
+
@property
|
|
4826
|
+
@pulumi.getter(name="notifySubscribers")
|
|
4827
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
4828
|
+
"""
|
|
4829
|
+
Whether to notify subscribers when the incident is triggered.
|
|
4830
|
+
"""
|
|
4831
|
+
return pulumi.get(self, "notify_subscribers")
|
|
4832
|
+
|
|
4833
|
+
@notify_subscribers.setter
|
|
4834
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
4835
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
4836
|
+
|
|
4837
|
+
@property
|
|
4838
|
+
@pulumi.getter(name="serviceId")
|
|
4839
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
4840
|
+
"""
|
|
4841
|
+
The status page service that this incident will be associated with.
|
|
4842
|
+
"""
|
|
4843
|
+
return pulumi.get(self, "service_id")
|
|
4844
|
+
|
|
4845
|
+
@service_id.setter
|
|
4846
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
4847
|
+
pulumi.set(self, "service_id", value)
|
|
4848
|
+
|
|
4849
|
+
@property
|
|
4850
|
+
@pulumi.getter
|
|
4851
|
+
def severity(self) -> pulumi.Input[str]:
|
|
4852
|
+
"""
|
|
4853
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
4854
|
+
"""
|
|
4855
|
+
return pulumi.get(self, "severity")
|
|
4856
|
+
|
|
4857
|
+
@severity.setter
|
|
4858
|
+
def severity(self, value: pulumi.Input[str]):
|
|
4859
|
+
pulumi.set(self, "severity", value)
|
|
4860
|
+
|
|
4861
|
+
|
|
4862
|
+
if not MYPY:
|
|
4863
|
+
class UrlMonitorAlertChannelSubscriptionArgsDict(TypedDict):
|
|
4864
|
+
activated: pulumi.Input[bool]
|
|
4865
|
+
"""
|
|
4866
|
+
Whether an alert should be sent to this channel.
|
|
4867
|
+
"""
|
|
4868
|
+
channel_id: pulumi.Input[int]
|
|
4869
|
+
"""
|
|
4870
|
+
The ID of the alert channel.
|
|
4871
|
+
"""
|
|
4872
|
+
elif False:
|
|
4873
|
+
UrlMonitorAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
4874
|
+
|
|
4875
|
+
@pulumi.input_type
|
|
4876
|
+
class UrlMonitorAlertChannelSubscriptionArgs:
|
|
4877
|
+
def __init__(__self__, *,
|
|
4878
|
+
activated: pulumi.Input[bool],
|
|
4879
|
+
channel_id: pulumi.Input[int]):
|
|
4880
|
+
"""
|
|
4881
|
+
:param pulumi.Input[bool] activated: Whether an alert should be sent to this channel.
|
|
4882
|
+
:param pulumi.Input[int] channel_id: The ID of the alert channel.
|
|
4883
|
+
"""
|
|
4884
|
+
pulumi.set(__self__, "activated", activated)
|
|
4885
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
4886
|
+
|
|
4887
|
+
@property
|
|
4888
|
+
@pulumi.getter
|
|
4889
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
4890
|
+
"""
|
|
4891
|
+
Whether an alert should be sent to this channel.
|
|
4892
|
+
"""
|
|
4893
|
+
return pulumi.get(self, "activated")
|
|
4894
|
+
|
|
4895
|
+
@activated.setter
|
|
4896
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
4897
|
+
pulumi.set(self, "activated", value)
|
|
4898
|
+
|
|
4899
|
+
@property
|
|
4900
|
+
@pulumi.getter(name="channelId")
|
|
4901
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
4902
|
+
"""
|
|
4903
|
+
The ID of the alert channel.
|
|
4904
|
+
"""
|
|
4905
|
+
return pulumi.get(self, "channel_id")
|
|
4906
|
+
|
|
4907
|
+
@channel_id.setter
|
|
4908
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
4909
|
+
pulumi.set(self, "channel_id", value)
|
|
4910
|
+
|
|
4911
|
+
|
|
4912
|
+
if not MYPY:
|
|
4913
|
+
class UrlMonitorAlertSettingsArgsDict(TypedDict):
|
|
4914
|
+
escalation_type: pulumi.Input[str]
|
|
4915
|
+
"""
|
|
4916
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
|
|
4917
|
+
"""
|
|
4918
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
4919
|
+
"""
|
|
4920
|
+
Configuration for parallel run failure threshold.
|
|
4921
|
+
"""
|
|
4922
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsReminderArgsDict']]]]
|
|
4923
|
+
"""
|
|
4924
|
+
Defines how often to send reminder notifications after initial alert.
|
|
4925
|
+
"""
|
|
4926
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
4927
|
+
"""
|
|
4928
|
+
Configuration for run-based escalation.
|
|
4929
|
+
"""
|
|
4930
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
4931
|
+
"""
|
|
4932
|
+
Configuration for time-based escalation.
|
|
4933
|
+
"""
|
|
4934
|
+
elif False:
|
|
4935
|
+
UrlMonitorAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4936
|
+
|
|
4937
|
+
@pulumi.input_type
|
|
4938
|
+
class UrlMonitorAlertSettingsArgs:
|
|
4939
|
+
def __init__(__self__, *,
|
|
4940
|
+
escalation_type: pulumi.Input[str],
|
|
4941
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
4942
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsReminderArgs']]]] = None,
|
|
4943
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
4944
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
4945
|
+
"""
|
|
4946
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
|
|
4947
|
+
:param pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsParallelRunFailureThresholdArgs']]] parallel_run_failure_thresholds: Configuration for parallel run failure threshold.
|
|
4948
|
+
:param pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsReminderArgs']]] reminders: Defines how often to send reminder notifications after initial alert.
|
|
4949
|
+
:param pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsRunBasedEscalationArgs']]] run_based_escalations: Configuration for run-based escalation.
|
|
4950
|
+
:param pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsTimeBasedEscalationArgs']]] time_based_escalations: Configuration for time-based escalation.
|
|
4951
|
+
"""
|
|
4952
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
4953
|
+
if parallel_run_failure_thresholds is not None:
|
|
4954
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
4955
|
+
if reminders is not None:
|
|
4956
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
4957
|
+
if run_based_escalations is not None:
|
|
4958
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
4959
|
+
if time_based_escalations is not None:
|
|
4960
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
4961
|
+
|
|
4962
|
+
@property
|
|
4963
|
+
@pulumi.getter(name="escalationType")
|
|
4964
|
+
def escalation_type(self) -> pulumi.Input[str]:
|
|
4965
|
+
"""
|
|
4966
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
|
|
4967
|
+
"""
|
|
4968
|
+
return pulumi.get(self, "escalation_type")
|
|
4969
|
+
|
|
4970
|
+
@escalation_type.setter
|
|
4971
|
+
def escalation_type(self, value: pulumi.Input[str]):
|
|
4972
|
+
pulumi.set(self, "escalation_type", value)
|
|
4973
|
+
|
|
4974
|
+
@property
|
|
4975
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
4976
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
4977
|
+
"""
|
|
4978
|
+
Configuration for parallel run failure threshold.
|
|
4979
|
+
"""
|
|
4980
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
4981
|
+
|
|
4982
|
+
@parallel_run_failure_thresholds.setter
|
|
4983
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
4984
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
4985
|
+
|
|
4986
|
+
@property
|
|
4987
|
+
@pulumi.getter
|
|
4988
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsReminderArgs']]]]:
|
|
4989
|
+
"""
|
|
4990
|
+
Defines how often to send reminder notifications after initial alert.
|
|
4991
|
+
"""
|
|
4992
|
+
return pulumi.get(self, "reminders")
|
|
4993
|
+
|
|
4994
|
+
@reminders.setter
|
|
4995
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsReminderArgs']]]]):
|
|
4996
|
+
pulumi.set(self, "reminders", value)
|
|
4997
|
+
|
|
4998
|
+
@property
|
|
4999
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
5000
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsRunBasedEscalationArgs']]]]:
|
|
5001
|
+
"""
|
|
5002
|
+
Configuration for run-based escalation.
|
|
5003
|
+
"""
|
|
5004
|
+
return pulumi.get(self, "run_based_escalations")
|
|
5005
|
+
|
|
5006
|
+
@run_based_escalations.setter
|
|
5007
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsRunBasedEscalationArgs']]]]):
|
|
5008
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
5009
|
+
|
|
5010
|
+
@property
|
|
5011
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
5012
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
5013
|
+
"""
|
|
5014
|
+
Configuration for time-based escalation.
|
|
5015
|
+
"""
|
|
5016
|
+
return pulumi.get(self, "time_based_escalations")
|
|
5017
|
+
|
|
5018
|
+
@time_based_escalations.setter
|
|
5019
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
5020
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
5021
|
+
|
|
5022
|
+
|
|
5023
|
+
if not MYPY:
|
|
5024
|
+
class UrlMonitorAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
5025
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
5026
|
+
"""
|
|
5027
|
+
Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
|
|
5028
|
+
"""
|
|
5029
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
5030
|
+
"""
|
|
5031
|
+
Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
|
|
5032
|
+
"""
|
|
5033
|
+
elif False:
|
|
5034
|
+
UrlMonitorAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
5035
|
+
|
|
5036
|
+
@pulumi.input_type
|
|
5037
|
+
class UrlMonitorAlertSettingsParallelRunFailureThresholdArgs:
|
|
5038
|
+
def __init__(__self__, *,
|
|
5039
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
5040
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
5041
|
+
"""
|
|
5042
|
+
:param pulumi.Input[bool] enabled: Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
|
|
5043
|
+
:param pulumi.Input[int] percentage: Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
|
|
5044
|
+
"""
|
|
5045
|
+
if enabled is not None:
|
|
5046
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
5047
|
+
if percentage is not None:
|
|
5048
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
5049
|
+
|
|
5050
|
+
@property
|
|
5051
|
+
@pulumi.getter
|
|
5052
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
5053
|
+
"""
|
|
5054
|
+
Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
|
|
5055
|
+
"""
|
|
5056
|
+
return pulumi.get(self, "enabled")
|
|
5057
|
+
|
|
5058
|
+
@enabled.setter
|
|
5059
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
5060
|
+
pulumi.set(self, "enabled", value)
|
|
5061
|
+
|
|
5062
|
+
@property
|
|
5063
|
+
@pulumi.getter
|
|
5064
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
5065
|
+
"""
|
|
5066
|
+
Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
|
|
5067
|
+
"""
|
|
5068
|
+
return pulumi.get(self, "percentage")
|
|
5069
|
+
|
|
5070
|
+
@percentage.setter
|
|
5071
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
5072
|
+
pulumi.set(self, "percentage", value)
|
|
5073
|
+
|
|
5074
|
+
|
|
5075
|
+
if not MYPY:
|
|
5076
|
+
class UrlMonitorAlertSettingsReminderArgsDict(TypedDict):
|
|
5077
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
5078
|
+
"""
|
|
5079
|
+
Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
|
|
5080
|
+
"""
|
|
5081
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
5082
|
+
"""
|
|
5083
|
+
Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
5084
|
+
"""
|
|
5085
|
+
elif False:
|
|
5086
|
+
UrlMonitorAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
5087
|
+
|
|
5088
|
+
@pulumi.input_type
|
|
5089
|
+
class UrlMonitorAlertSettingsReminderArgs:
|
|
5090
|
+
def __init__(__self__, *,
|
|
5091
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
5092
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
5093
|
+
"""
|
|
5094
|
+
:param pulumi.Input[int] amount: Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
|
|
5095
|
+
:param pulumi.Input[int] interval: Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
5096
|
+
"""
|
|
5097
|
+
if amount is not None:
|
|
5098
|
+
pulumi.set(__self__, "amount", amount)
|
|
5099
|
+
if interval is not None:
|
|
5100
|
+
pulumi.set(__self__, "interval", interval)
|
|
5101
|
+
|
|
5102
|
+
@property
|
|
5103
|
+
@pulumi.getter
|
|
5104
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
2972
5105
|
"""
|
|
2973
|
-
|
|
5106
|
+
Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
|
|
2974
5107
|
"""
|
|
2975
|
-
return pulumi.get(self, "
|
|
5108
|
+
return pulumi.get(self, "amount")
|
|
2976
5109
|
|
|
2977
|
-
@
|
|
2978
|
-
def
|
|
2979
|
-
pulumi.set(self, "
|
|
5110
|
+
@amount.setter
|
|
5111
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
5112
|
+
pulumi.set(self, "amount", value)
|
|
2980
5113
|
|
|
2981
5114
|
@property
|
|
2982
5115
|
@pulumi.getter
|
|
2983
|
-
def
|
|
5116
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
2984
5117
|
"""
|
|
2985
|
-
|
|
5118
|
+
Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2986
5119
|
"""
|
|
2987
|
-
return pulumi.get(self, "
|
|
5120
|
+
return pulumi.get(self, "interval")
|
|
2988
5121
|
|
|
2989
|
-
@
|
|
2990
|
-
def
|
|
2991
|
-
pulumi.set(self, "
|
|
5122
|
+
@interval.setter
|
|
5123
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
5124
|
+
pulumi.set(self, "interval", value)
|
|
5125
|
+
|
|
5126
|
+
|
|
5127
|
+
if not MYPY:
|
|
5128
|
+
class UrlMonitorAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
5129
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
5130
|
+
"""
|
|
5131
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between `1` and `5`. (Default `1`).
|
|
5132
|
+
"""
|
|
5133
|
+
elif False:
|
|
5134
|
+
UrlMonitorAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5135
|
+
|
|
5136
|
+
@pulumi.input_type
|
|
5137
|
+
class UrlMonitorAlertSettingsRunBasedEscalationArgs:
|
|
5138
|
+
def __init__(__self__, *,
|
|
5139
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
5140
|
+
"""
|
|
5141
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between `1` and `5`. (Default `1`).
|
|
5142
|
+
"""
|
|
5143
|
+
if failed_run_threshold is not None:
|
|
5144
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
5145
|
+
|
|
5146
|
+
@property
|
|
5147
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
5148
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
5149
|
+
"""
|
|
5150
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between `1` and `5`. (Default `1`).
|
|
5151
|
+
"""
|
|
5152
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
5153
|
+
|
|
5154
|
+
@failed_run_threshold.setter
|
|
5155
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
5156
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
5157
|
+
|
|
5158
|
+
|
|
5159
|
+
if not MYPY:
|
|
5160
|
+
class UrlMonitorAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
5161
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
5162
|
+
"""
|
|
5163
|
+
After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
5164
|
+
"""
|
|
5165
|
+
elif False:
|
|
5166
|
+
UrlMonitorAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5167
|
+
|
|
5168
|
+
@pulumi.input_type
|
|
5169
|
+
class UrlMonitorAlertSettingsTimeBasedEscalationArgs:
|
|
5170
|
+
def __init__(__self__, *,
|
|
5171
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
5172
|
+
"""
|
|
5173
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
5174
|
+
"""
|
|
5175
|
+
if minutes_failing_threshold is not None:
|
|
5176
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
5177
|
+
|
|
5178
|
+
@property
|
|
5179
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
5180
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
5181
|
+
"""
|
|
5182
|
+
After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
5183
|
+
"""
|
|
5184
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
5185
|
+
|
|
5186
|
+
@minutes_failing_threshold.setter
|
|
5187
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
5188
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
5189
|
+
|
|
5190
|
+
|
|
5191
|
+
if not MYPY:
|
|
5192
|
+
class UrlMonitorRequestArgsDict(TypedDict):
|
|
5193
|
+
url: pulumi.Input[str]
|
|
5194
|
+
"""
|
|
5195
|
+
The URL to monitor. Must be a valid HTTP or HTTPS URL.
|
|
5196
|
+
"""
|
|
5197
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['UrlMonitorRequestAssertionArgsDict']]]]
|
|
5198
|
+
"""
|
|
5199
|
+
Assertions to validate the HTTP response. URL monitors only support status code assertions.
|
|
5200
|
+
"""
|
|
5201
|
+
follow_redirects: NotRequired[pulumi.Input[bool]]
|
|
5202
|
+
"""
|
|
5203
|
+
Whether to follow HTTP redirects automatically. (Default `true`).
|
|
5204
|
+
"""
|
|
5205
|
+
ip_family: NotRequired[pulumi.Input[str]]
|
|
5206
|
+
"""
|
|
5207
|
+
IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
|
|
5208
|
+
"""
|
|
5209
|
+
skip_ssl: NotRequired[pulumi.Input[bool]]
|
|
5210
|
+
"""
|
|
5211
|
+
Whether to skip SSL certificate verification. (Default `false`).
|
|
5212
|
+
"""
|
|
5213
|
+
elif False:
|
|
5214
|
+
UrlMonitorRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
5215
|
+
|
|
5216
|
+
@pulumi.input_type
|
|
5217
|
+
class UrlMonitorRequestArgs:
|
|
5218
|
+
def __init__(__self__, *,
|
|
5219
|
+
url: pulumi.Input[str],
|
|
5220
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorRequestAssertionArgs']]]] = None,
|
|
5221
|
+
follow_redirects: Optional[pulumi.Input[bool]] = None,
|
|
5222
|
+
ip_family: Optional[pulumi.Input[str]] = None,
|
|
5223
|
+
skip_ssl: Optional[pulumi.Input[bool]] = None):
|
|
5224
|
+
"""
|
|
5225
|
+
:param pulumi.Input[str] url: The URL to monitor. Must be a valid HTTP or HTTPS URL.
|
|
5226
|
+
:param pulumi.Input[Sequence[pulumi.Input['UrlMonitorRequestAssertionArgs']]] assertions: Assertions to validate the HTTP response. URL monitors only support status code assertions.
|
|
5227
|
+
:param pulumi.Input[bool] follow_redirects: Whether to follow HTTP redirects automatically. (Default `true`).
|
|
5228
|
+
:param pulumi.Input[str] ip_family: IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
|
|
5229
|
+
:param pulumi.Input[bool] skip_ssl: Whether to skip SSL certificate verification. (Default `false`).
|
|
5230
|
+
"""
|
|
5231
|
+
pulumi.set(__self__, "url", url)
|
|
5232
|
+
if assertions is not None:
|
|
5233
|
+
pulumi.set(__self__, "assertions", assertions)
|
|
5234
|
+
if follow_redirects is not None:
|
|
5235
|
+
pulumi.set(__self__, "follow_redirects", follow_redirects)
|
|
5236
|
+
if ip_family is not None:
|
|
5237
|
+
pulumi.set(__self__, "ip_family", ip_family)
|
|
5238
|
+
if skip_ssl is not None:
|
|
5239
|
+
pulumi.set(__self__, "skip_ssl", skip_ssl)
|
|
2992
5240
|
|
|
2993
5241
|
@property
|
|
2994
5242
|
@pulumi.getter
|
|
2995
|
-
def
|
|
5243
|
+
def url(self) -> pulumi.Input[str]:
|
|
2996
5244
|
"""
|
|
2997
|
-
|
|
5245
|
+
The URL to monitor. Must be a valid HTTP or HTTPS URL.
|
|
5246
|
+
"""
|
|
5247
|
+
return pulumi.get(self, "url")
|
|
5248
|
+
|
|
5249
|
+
@url.setter
|
|
5250
|
+
def url(self, value: pulumi.Input[str]):
|
|
5251
|
+
pulumi.set(self, "url", value)
|
|
5252
|
+
|
|
5253
|
+
@property
|
|
5254
|
+
@pulumi.getter
|
|
5255
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorRequestAssertionArgs']]]]:
|
|
5256
|
+
"""
|
|
5257
|
+
Assertions to validate the HTTP response. URL monitors only support status code assertions.
|
|
2998
5258
|
"""
|
|
2999
5259
|
return pulumi.get(self, "assertions")
|
|
3000
5260
|
|
|
3001
5261
|
@assertions.setter
|
|
3002
|
-
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['
|
|
5262
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UrlMonitorRequestAssertionArgs']]]]):
|
|
3003
5263
|
pulumi.set(self, "assertions", value)
|
|
3004
5264
|
|
|
3005
5265
|
@property
|
|
3006
|
-
@pulumi.getter
|
|
3007
|
-
def
|
|
5266
|
+
@pulumi.getter(name="followRedirects")
|
|
5267
|
+
def follow_redirects(self) -> Optional[pulumi.Input[bool]]:
|
|
3008
5268
|
"""
|
|
3009
|
-
|
|
5269
|
+
Whether to follow HTTP redirects automatically. (Default `true`).
|
|
3010
5270
|
"""
|
|
3011
|
-
return pulumi.get(self, "
|
|
5271
|
+
return pulumi.get(self, "follow_redirects")
|
|
3012
5272
|
|
|
3013
|
-
@
|
|
3014
|
-
def
|
|
3015
|
-
pulumi.set(self, "
|
|
5273
|
+
@follow_redirects.setter
|
|
5274
|
+
def follow_redirects(self, value: Optional[pulumi.Input[bool]]):
|
|
5275
|
+
pulumi.set(self, "follow_redirects", value)
|
|
3016
5276
|
|
|
3017
5277
|
@property
|
|
3018
5278
|
@pulumi.getter(name="ipFamily")
|
|
3019
5279
|
def ip_family(self) -> Optional[pulumi.Input[str]]:
|
|
3020
5280
|
"""
|
|
3021
|
-
|
|
5281
|
+
IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
|
|
3022
5282
|
"""
|
|
3023
5283
|
return pulumi.get(self, "ip_family")
|
|
3024
5284
|
|
|
@@ -3026,45 +5286,60 @@ class TcpCheckRequestArgs:
|
|
|
3026
5286
|
def ip_family(self, value: Optional[pulumi.Input[str]]):
|
|
3027
5287
|
pulumi.set(self, "ip_family", value)
|
|
3028
5288
|
|
|
5289
|
+
@property
|
|
5290
|
+
@pulumi.getter(name="skipSsl")
|
|
5291
|
+
def skip_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
5292
|
+
"""
|
|
5293
|
+
Whether to skip SSL certificate verification. (Default `false`).
|
|
5294
|
+
"""
|
|
5295
|
+
return pulumi.get(self, "skip_ssl")
|
|
5296
|
+
|
|
5297
|
+
@skip_ssl.setter
|
|
5298
|
+
def skip_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
5299
|
+
pulumi.set(self, "skip_ssl", value)
|
|
5300
|
+
|
|
3029
5301
|
|
|
3030
5302
|
if not MYPY:
|
|
3031
|
-
class
|
|
5303
|
+
class UrlMonitorRequestAssertionArgsDict(TypedDict):
|
|
3032
5304
|
comparison: pulumi.Input[str]
|
|
3033
5305
|
"""
|
|
3034
|
-
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `
|
|
5306
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
|
|
3035
5307
|
"""
|
|
3036
5308
|
source: pulumi.Input[str]
|
|
3037
5309
|
"""
|
|
3038
|
-
The source of the asserted value.
|
|
5310
|
+
The source of the asserted value. The only allowed value is `STATUS_CODE`.
|
|
5311
|
+
"""
|
|
5312
|
+
target: pulumi.Input[str]
|
|
5313
|
+
"""
|
|
5314
|
+
The target value. Typically `200` when the source is `STATUS_CODE`.
|
|
3039
5315
|
"""
|
|
3040
5316
|
property: NotRequired[pulumi.Input[str]]
|
|
3041
|
-
target: NotRequired[pulumi.Input[str]]
|
|
3042
5317
|
elif False:
|
|
3043
|
-
|
|
5318
|
+
UrlMonitorRequestAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
3044
5319
|
|
|
3045
5320
|
@pulumi.input_type
|
|
3046
|
-
class
|
|
5321
|
+
class UrlMonitorRequestAssertionArgs:
|
|
3047
5322
|
def __init__(__self__, *,
|
|
3048
5323
|
comparison: pulumi.Input[str],
|
|
3049
5324
|
source: pulumi.Input[str],
|
|
3050
|
-
|
|
3051
|
-
|
|
5325
|
+
target: pulumi.Input[str],
|
|
5326
|
+
property: Optional[pulumi.Input[str]] = None):
|
|
3052
5327
|
"""
|
|
3053
|
-
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `
|
|
3054
|
-
:param pulumi.Input[str] source: The source of the asserted value.
|
|
5328
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
|
|
5329
|
+
:param pulumi.Input[str] source: The source of the asserted value. The only allowed value is `STATUS_CODE`.
|
|
5330
|
+
:param pulumi.Input[str] target: The target value. Typically `200` when the source is `STATUS_CODE`.
|
|
3055
5331
|
"""
|
|
3056
5332
|
pulumi.set(__self__, "comparison", comparison)
|
|
3057
5333
|
pulumi.set(__self__, "source", source)
|
|
5334
|
+
pulumi.set(__self__, "target", target)
|
|
3058
5335
|
if property is not None:
|
|
3059
5336
|
pulumi.set(__self__, "property", property)
|
|
3060
|
-
if target is not None:
|
|
3061
|
-
pulumi.set(__self__, "target", target)
|
|
3062
5337
|
|
|
3063
5338
|
@property
|
|
3064
5339
|
@pulumi.getter
|
|
3065
5340
|
def comparison(self) -> pulumi.Input[str]:
|
|
3066
5341
|
"""
|
|
3067
|
-
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `
|
|
5342
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
|
|
3068
5343
|
"""
|
|
3069
5344
|
return pulumi.get(self, "comparison")
|
|
3070
5345
|
|
|
@@ -3076,7 +5351,7 @@ class TcpCheckRequestAssertionArgs:
|
|
|
3076
5351
|
@pulumi.getter
|
|
3077
5352
|
def source(self) -> pulumi.Input[str]:
|
|
3078
5353
|
"""
|
|
3079
|
-
The source of the asserted value.
|
|
5354
|
+
The source of the asserted value. The only allowed value is `STATUS_CODE`.
|
|
3080
5355
|
"""
|
|
3081
5356
|
return pulumi.get(self, "source")
|
|
3082
5357
|
|
|
@@ -3086,11 +5361,14 @@ class TcpCheckRequestAssertionArgs:
|
|
|
3086
5361
|
|
|
3087
5362
|
@property
|
|
3088
5363
|
@pulumi.getter
|
|
3089
|
-
def target(self) ->
|
|
5364
|
+
def target(self) -> pulumi.Input[str]:
|
|
5365
|
+
"""
|
|
5366
|
+
The target value. Typically `200` when the source is `STATUS_CODE`.
|
|
5367
|
+
"""
|
|
3090
5368
|
return pulumi.get(self, "target")
|
|
3091
5369
|
|
|
3092
5370
|
@target.setter
|
|
3093
|
-
def target(self, value:
|
|
5371
|
+
def target(self, value: pulumi.Input[str]):
|
|
3094
5372
|
pulumi.set(self, "target", value)
|
|
3095
5373
|
|
|
3096
5374
|
@property
|
|
@@ -3104,32 +5382,32 @@ class TcpCheckRequestAssertionArgs:
|
|
|
3104
5382
|
|
|
3105
5383
|
|
|
3106
5384
|
if not MYPY:
|
|
3107
|
-
class
|
|
5385
|
+
class UrlMonitorRetryStrategyArgsDict(TypedDict):
|
|
3108
5386
|
type: pulumi.Input[str]
|
|
3109
5387
|
"""
|
|
3110
|
-
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`,
|
|
5388
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, and `EXPONENTIAL`.
|
|
3111
5389
|
"""
|
|
3112
5390
|
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
3113
5391
|
"""
|
|
3114
|
-
The number of seconds to wait before the first retry attempt.
|
|
5392
|
+
The number of seconds to wait before the first retry attempt. (Default `60`).
|
|
3115
5393
|
"""
|
|
3116
5394
|
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
3117
5395
|
"""
|
|
3118
|
-
The total amount of time to continue retrying the
|
|
5396
|
+
The total amount of time to continue retrying the monitor (maximum 600 seconds). (Default `600`).
|
|
3119
5397
|
"""
|
|
3120
5398
|
max_retries: NotRequired[pulumi.Input[int]]
|
|
3121
5399
|
"""
|
|
3122
|
-
The maximum number of times to retry the
|
|
5400
|
+
The maximum number of times to retry the monitor. Value must be between `1` and `10`. (Default `2`).
|
|
3123
5401
|
"""
|
|
3124
5402
|
same_region: NotRequired[pulumi.Input[bool]]
|
|
3125
5403
|
"""
|
|
3126
|
-
Whether retries should be run in the same region as the initial
|
|
5404
|
+
Whether retries should be run in the same region as the initial monitor run. (Default `true`).
|
|
3127
5405
|
"""
|
|
3128
5406
|
elif False:
|
|
3129
|
-
|
|
5407
|
+
UrlMonitorRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3130
5408
|
|
|
3131
5409
|
@pulumi.input_type
|
|
3132
|
-
class
|
|
5410
|
+
class UrlMonitorRetryStrategyArgs:
|
|
3133
5411
|
def __init__(__self__, *,
|
|
3134
5412
|
type: pulumi.Input[str],
|
|
3135
5413
|
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
@@ -3137,11 +5415,11 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3137
5415
|
max_retries: Optional[pulumi.Input[int]] = None,
|
|
3138
5416
|
same_region: Optional[pulumi.Input[bool]] = None):
|
|
3139
5417
|
"""
|
|
3140
|
-
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`,
|
|
3141
|
-
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
3142
|
-
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the
|
|
3143
|
-
:param pulumi.Input[int] max_retries: The maximum number of times to retry the
|
|
3144
|
-
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial
|
|
5418
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, and `EXPONENTIAL`.
|
|
5419
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
|
|
5420
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the monitor (maximum 600 seconds). (Default `600`).
|
|
5421
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the monitor. Value must be between `1` and `10`. (Default `2`).
|
|
5422
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial monitor run. (Default `true`).
|
|
3145
5423
|
"""
|
|
3146
5424
|
pulumi.set(__self__, "type", type)
|
|
3147
5425
|
if base_backoff_seconds is not None:
|
|
@@ -3157,7 +5435,7 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3157
5435
|
@pulumi.getter
|
|
3158
5436
|
def type(self) -> pulumi.Input[str]:
|
|
3159
5437
|
"""
|
|
3160
|
-
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`,
|
|
5438
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, and `EXPONENTIAL`.
|
|
3161
5439
|
"""
|
|
3162
5440
|
return pulumi.get(self, "type")
|
|
3163
5441
|
|
|
@@ -3169,7 +5447,7 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3169
5447
|
@pulumi.getter(name="baseBackoffSeconds")
|
|
3170
5448
|
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
3171
5449
|
"""
|
|
3172
|
-
The number of seconds to wait before the first retry attempt.
|
|
5450
|
+
The number of seconds to wait before the first retry attempt. (Default `60`).
|
|
3173
5451
|
"""
|
|
3174
5452
|
return pulumi.get(self, "base_backoff_seconds")
|
|
3175
5453
|
|
|
@@ -3181,7 +5459,7 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3181
5459
|
@pulumi.getter(name="maxDurationSeconds")
|
|
3182
5460
|
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
3183
5461
|
"""
|
|
3184
|
-
The total amount of time to continue retrying the
|
|
5462
|
+
The total amount of time to continue retrying the monitor (maximum 600 seconds). (Default `600`).
|
|
3185
5463
|
"""
|
|
3186
5464
|
return pulumi.get(self, "max_duration_seconds")
|
|
3187
5465
|
|
|
@@ -3193,7 +5471,7 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3193
5471
|
@pulumi.getter(name="maxRetries")
|
|
3194
5472
|
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
3195
5473
|
"""
|
|
3196
|
-
The maximum number of times to retry the
|
|
5474
|
+
The maximum number of times to retry the monitor. Value must be between `1` and `10`. (Default `2`).
|
|
3197
5475
|
"""
|
|
3198
5476
|
return pulumi.get(self, "max_retries")
|
|
3199
5477
|
|
|
@@ -3205,7 +5483,7 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3205
5483
|
@pulumi.getter(name="sameRegion")
|
|
3206
5484
|
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
3207
5485
|
"""
|
|
3208
|
-
Whether retries should be run in the same region as the initial
|
|
5486
|
+
Whether retries should be run in the same region as the initial monitor run. (Default `true`).
|
|
3209
5487
|
"""
|
|
3210
5488
|
return pulumi.get(self, "same_region")
|
|
3211
5489
|
|
|
@@ -3214,3 +5492,110 @@ class TcpCheckRetryStrategyArgs:
|
|
|
3214
5492
|
pulumi.set(self, "same_region", value)
|
|
3215
5493
|
|
|
3216
5494
|
|
|
5495
|
+
if not MYPY:
|
|
5496
|
+
class UrlMonitorTriggerIncidentArgsDict(TypedDict):
|
|
5497
|
+
description: pulumi.Input[str]
|
|
5498
|
+
"""
|
|
5499
|
+
A detailed description of the incident.
|
|
5500
|
+
"""
|
|
5501
|
+
name: pulumi.Input[str]
|
|
5502
|
+
"""
|
|
5503
|
+
The name of the incident.
|
|
5504
|
+
"""
|
|
5505
|
+
notify_subscribers: pulumi.Input[bool]
|
|
5506
|
+
"""
|
|
5507
|
+
Whether to notify subscribers when the incident is triggered.
|
|
5508
|
+
"""
|
|
5509
|
+
service_id: pulumi.Input[str]
|
|
5510
|
+
"""
|
|
5511
|
+
The status page service that this incident will be associated with.
|
|
5512
|
+
"""
|
|
5513
|
+
severity: pulumi.Input[str]
|
|
5514
|
+
"""
|
|
5515
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
5516
|
+
"""
|
|
5517
|
+
elif False:
|
|
5518
|
+
UrlMonitorTriggerIncidentArgsDict: TypeAlias = Mapping[str, Any]
|
|
5519
|
+
|
|
5520
|
+
@pulumi.input_type
|
|
5521
|
+
class UrlMonitorTriggerIncidentArgs:
|
|
5522
|
+
def __init__(__self__, *,
|
|
5523
|
+
description: pulumi.Input[str],
|
|
5524
|
+
name: pulumi.Input[str],
|
|
5525
|
+
notify_subscribers: pulumi.Input[bool],
|
|
5526
|
+
service_id: pulumi.Input[str],
|
|
5527
|
+
severity: pulumi.Input[str]):
|
|
5528
|
+
"""
|
|
5529
|
+
:param pulumi.Input[str] description: A detailed description of the incident.
|
|
5530
|
+
:param pulumi.Input[str] name: The name of the incident.
|
|
5531
|
+
:param pulumi.Input[bool] notify_subscribers: Whether to notify subscribers when the incident is triggered.
|
|
5532
|
+
:param pulumi.Input[str] service_id: The status page service that this incident will be associated with.
|
|
5533
|
+
:param pulumi.Input[str] severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
5534
|
+
"""
|
|
5535
|
+
pulumi.set(__self__, "description", description)
|
|
5536
|
+
pulumi.set(__self__, "name", name)
|
|
5537
|
+
pulumi.set(__self__, "notify_subscribers", notify_subscribers)
|
|
5538
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
5539
|
+
pulumi.set(__self__, "severity", severity)
|
|
5540
|
+
|
|
5541
|
+
@property
|
|
5542
|
+
@pulumi.getter
|
|
5543
|
+
def description(self) -> pulumi.Input[str]:
|
|
5544
|
+
"""
|
|
5545
|
+
A detailed description of the incident.
|
|
5546
|
+
"""
|
|
5547
|
+
return pulumi.get(self, "description")
|
|
5548
|
+
|
|
5549
|
+
@description.setter
|
|
5550
|
+
def description(self, value: pulumi.Input[str]):
|
|
5551
|
+
pulumi.set(self, "description", value)
|
|
5552
|
+
|
|
5553
|
+
@property
|
|
5554
|
+
@pulumi.getter
|
|
5555
|
+
def name(self) -> pulumi.Input[str]:
|
|
5556
|
+
"""
|
|
5557
|
+
The name of the incident.
|
|
5558
|
+
"""
|
|
5559
|
+
return pulumi.get(self, "name")
|
|
5560
|
+
|
|
5561
|
+
@name.setter
|
|
5562
|
+
def name(self, value: pulumi.Input[str]):
|
|
5563
|
+
pulumi.set(self, "name", value)
|
|
5564
|
+
|
|
5565
|
+
@property
|
|
5566
|
+
@pulumi.getter(name="notifySubscribers")
|
|
5567
|
+
def notify_subscribers(self) -> pulumi.Input[bool]:
|
|
5568
|
+
"""
|
|
5569
|
+
Whether to notify subscribers when the incident is triggered.
|
|
5570
|
+
"""
|
|
5571
|
+
return pulumi.get(self, "notify_subscribers")
|
|
5572
|
+
|
|
5573
|
+
@notify_subscribers.setter
|
|
5574
|
+
def notify_subscribers(self, value: pulumi.Input[bool]):
|
|
5575
|
+
pulumi.set(self, "notify_subscribers", value)
|
|
5576
|
+
|
|
5577
|
+
@property
|
|
5578
|
+
@pulumi.getter(name="serviceId")
|
|
5579
|
+
def service_id(self) -> pulumi.Input[str]:
|
|
5580
|
+
"""
|
|
5581
|
+
The status page service that this incident will be associated with.
|
|
5582
|
+
"""
|
|
5583
|
+
return pulumi.get(self, "service_id")
|
|
5584
|
+
|
|
5585
|
+
@service_id.setter
|
|
5586
|
+
def service_id(self, value: pulumi.Input[str]):
|
|
5587
|
+
pulumi.set(self, "service_id", value)
|
|
5588
|
+
|
|
5589
|
+
@property
|
|
5590
|
+
@pulumi.getter
|
|
5591
|
+
def severity(self) -> pulumi.Input[str]:
|
|
5592
|
+
"""
|
|
5593
|
+
The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
|
|
5594
|
+
"""
|
|
5595
|
+
return pulumi.get(self, "severity")
|
|
5596
|
+
|
|
5597
|
+
@severity.setter
|
|
5598
|
+
def severity(self, value: pulumi.Input[str]):
|
|
5599
|
+
pulumi.set(self, "severity", value)
|
|
5600
|
+
|
|
5601
|
+
|