pulumi-newrelic 5.21.0a1711361572__py3-none-any.whl → 5.22.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_newrelic/browser_application.py +62 -68
- pulumi_newrelic/synthetics/broken_links_monitor.py +124 -12
- pulumi_newrelic/synthetics/cert_check_monitor.py +128 -14
- pulumi_newrelic/synthetics/step_monitor.py +182 -4
- {pulumi_newrelic-5.21.0a1711361572.dist-info → pulumi_newrelic-5.22.0.dist-info}/METADATA +1 -1
- {pulumi_newrelic-5.21.0a1711361572.dist-info → pulumi_newrelic-5.22.0.dist-info}/RECORD +8 -8
- {pulumi_newrelic-5.21.0a1711361572.dist-info → pulumi_newrelic-5.22.0.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.21.0a1711361572.dist-info → pulumi_newrelic-5.22.0.dist-info}/top_level.txt +0 -0
|
@@ -24,6 +24,8 @@ class CertCheckMonitorArgs:
|
|
|
24
24
|
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
25
25
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
26
26
|
name: Optional[pulumi.Input[str]] = None,
|
|
27
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
28
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
27
29
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None):
|
|
28
30
|
"""
|
|
29
31
|
The set of arguments for constructing a CertCheckMonitor resource.
|
|
@@ -35,6 +37,10 @@ class CertCheckMonitorArgs:
|
|
|
35
37
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
36
38
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Valid public locations are https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
37
39
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
40
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
41
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
42
|
+
|
|
43
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
38
44
|
:param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
39
45
|
"""
|
|
40
46
|
pulumi.set(__self__, "certificate_expiration", certificate_expiration)
|
|
@@ -49,6 +55,10 @@ class CertCheckMonitorArgs:
|
|
|
49
55
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
50
56
|
if name is not None:
|
|
51
57
|
pulumi.set(__self__, "name", name)
|
|
58
|
+
if runtime_type is not None:
|
|
59
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
60
|
+
if runtime_type_version is not None:
|
|
61
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
52
62
|
if tags is not None:
|
|
53
63
|
pulumi.set(__self__, "tags", tags)
|
|
54
64
|
|
|
@@ -148,6 +158,32 @@ class CertCheckMonitorArgs:
|
|
|
148
158
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
149
159
|
pulumi.set(self, "name", value)
|
|
150
160
|
|
|
161
|
+
@property
|
|
162
|
+
@pulumi.getter(name="runtimeType")
|
|
163
|
+
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
164
|
+
"""
|
|
165
|
+
The runtime that the monitor will use to run jobs.
|
|
166
|
+
"""
|
|
167
|
+
return pulumi.get(self, "runtime_type")
|
|
168
|
+
|
|
169
|
+
@runtime_type.setter
|
|
170
|
+
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
171
|
+
pulumi.set(self, "runtime_type", value)
|
|
172
|
+
|
|
173
|
+
@property
|
|
174
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
175
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
176
|
+
"""
|
|
177
|
+
The specific version of the runtime type selected.
|
|
178
|
+
|
|
179
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
180
|
+
"""
|
|
181
|
+
return pulumi.get(self, "runtime_type_version")
|
|
182
|
+
|
|
183
|
+
@runtime_type_version.setter
|
|
184
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
185
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
186
|
+
|
|
151
187
|
@property
|
|
152
188
|
@pulumi.getter
|
|
153
189
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]:
|
|
@@ -172,6 +208,8 @@ class _CertCheckMonitorState:
|
|
|
172
208
|
name: Optional[pulumi.Input[str]] = None,
|
|
173
209
|
period: Optional[pulumi.Input[str]] = None,
|
|
174
210
|
period_in_minutes: Optional[pulumi.Input[int]] = None,
|
|
211
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
212
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
175
213
|
status: Optional[pulumi.Input[str]] = None,
|
|
176
214
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None):
|
|
177
215
|
"""
|
|
@@ -184,6 +222,10 @@ class _CertCheckMonitorState:
|
|
|
184
222
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
185
223
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
186
224
|
:param pulumi.Input[int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
225
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
226
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
227
|
+
|
|
228
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
187
229
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
188
230
|
:param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
189
231
|
"""
|
|
@@ -203,6 +245,10 @@ class _CertCheckMonitorState:
|
|
|
203
245
|
pulumi.set(__self__, "period", period)
|
|
204
246
|
if period_in_minutes is not None:
|
|
205
247
|
pulumi.set(__self__, "period_in_minutes", period_in_minutes)
|
|
248
|
+
if runtime_type is not None:
|
|
249
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
250
|
+
if runtime_type_version is not None:
|
|
251
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
206
252
|
if status is not None:
|
|
207
253
|
pulumi.set(__self__, "status", status)
|
|
208
254
|
if tags is not None:
|
|
@@ -304,6 +350,32 @@ class _CertCheckMonitorState:
|
|
|
304
350
|
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
305
351
|
pulumi.set(self, "period_in_minutes", value)
|
|
306
352
|
|
|
353
|
+
@property
|
|
354
|
+
@pulumi.getter(name="runtimeType")
|
|
355
|
+
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
356
|
+
"""
|
|
357
|
+
The runtime that the monitor will use to run jobs.
|
|
358
|
+
"""
|
|
359
|
+
return pulumi.get(self, "runtime_type")
|
|
360
|
+
|
|
361
|
+
@runtime_type.setter
|
|
362
|
+
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
363
|
+
pulumi.set(self, "runtime_type", value)
|
|
364
|
+
|
|
365
|
+
@property
|
|
366
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
367
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
368
|
+
"""
|
|
369
|
+
The specific version of the runtime type selected.
|
|
370
|
+
|
|
371
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
372
|
+
"""
|
|
373
|
+
return pulumi.get(self, "runtime_type_version")
|
|
374
|
+
|
|
375
|
+
@runtime_type_version.setter
|
|
376
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
377
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
378
|
+
|
|
307
379
|
@property
|
|
308
380
|
@pulumi.getter
|
|
309
381
|
def status(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -341,6 +413,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
341
413
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
342
414
|
name: Optional[pulumi.Input[str]] = None,
|
|
343
415
|
period: Optional[pulumi.Input[str]] = None,
|
|
416
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
417
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
344
418
|
status: Optional[pulumi.Input[str]] = None,
|
|
345
419
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CertCheckMonitorTagArgs']]]]] = None,
|
|
346
420
|
__props__=None):
|
|
@@ -354,11 +428,13 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
354
428
|
import pulumi
|
|
355
429
|
import pulumi_newrelic as newrelic
|
|
356
430
|
|
|
357
|
-
|
|
431
|
+
foo = newrelic.synthetics.CertCheckMonitor("foo",
|
|
358
432
|
certificate_expiration=10,
|
|
359
433
|
domain="www.example.com",
|
|
360
434
|
locations_publics=["AP_SOUTH_1"],
|
|
361
435
|
period="EVERY_6_HOURS",
|
|
436
|
+
runtime_type="NODE_API",
|
|
437
|
+
runtime_type_version="16.10",
|
|
362
438
|
status="ENABLED",
|
|
363
439
|
tags=[newrelic.synthetics.CertCheckMonitorTagArgs(
|
|
364
440
|
key="some_key",
|
|
@@ -381,12 +457,13 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
381
457
|
import pulumi
|
|
382
458
|
import pulumi_newrelic as newrelic
|
|
383
459
|
|
|
384
|
-
|
|
385
|
-
description="
|
|
460
|
+
foo_private_location = newrelic.synthetics.PrivateLocation("fooPrivateLocation",
|
|
461
|
+
description="Sample Private Location Description",
|
|
386
462
|
verified_script_execution=False)
|
|
387
|
-
|
|
388
|
-
domain="
|
|
389
|
-
locations_privates=[
|
|
463
|
+
foo_cert_check_monitor = newrelic.synthetics.CertCheckMonitor("fooCertCheckMonitor",
|
|
464
|
+
domain="www.one.example.com",
|
|
465
|
+
locations_privates=[foo_private_location.id],
|
|
466
|
+
certificate_expiration=10,
|
|
390
467
|
period="EVERY_6_HOURS",
|
|
391
468
|
status="ENABLED",
|
|
392
469
|
tags=[newrelic.synthetics.CertCheckMonitorTagArgs(
|
|
@@ -398,7 +475,7 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
398
475
|
|
|
399
476
|
## Import
|
|
400
477
|
|
|
401
|
-
|
|
478
|
+
A cert check monitor can be imported using its GUID, using the following command.
|
|
402
479
|
|
|
403
480
|
bash
|
|
404
481
|
|
|
@@ -415,6 +492,10 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
415
492
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Valid public locations are https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
416
493
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
417
494
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
495
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
496
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
497
|
+
|
|
498
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
418
499
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
419
500
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CertCheckMonitorTagArgs']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
420
501
|
"""
|
|
@@ -434,11 +515,13 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
434
515
|
import pulumi
|
|
435
516
|
import pulumi_newrelic as newrelic
|
|
436
517
|
|
|
437
|
-
|
|
518
|
+
foo = newrelic.synthetics.CertCheckMonitor("foo",
|
|
438
519
|
certificate_expiration=10,
|
|
439
520
|
domain="www.example.com",
|
|
440
521
|
locations_publics=["AP_SOUTH_1"],
|
|
441
522
|
period="EVERY_6_HOURS",
|
|
523
|
+
runtime_type="NODE_API",
|
|
524
|
+
runtime_type_version="16.10",
|
|
442
525
|
status="ENABLED",
|
|
443
526
|
tags=[newrelic.synthetics.CertCheckMonitorTagArgs(
|
|
444
527
|
key="some_key",
|
|
@@ -461,12 +544,13 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
461
544
|
import pulumi
|
|
462
545
|
import pulumi_newrelic as newrelic
|
|
463
546
|
|
|
464
|
-
|
|
465
|
-
description="
|
|
547
|
+
foo_private_location = newrelic.synthetics.PrivateLocation("fooPrivateLocation",
|
|
548
|
+
description="Sample Private Location Description",
|
|
466
549
|
verified_script_execution=False)
|
|
467
|
-
|
|
468
|
-
domain="
|
|
469
|
-
locations_privates=[
|
|
550
|
+
foo_cert_check_monitor = newrelic.synthetics.CertCheckMonitor("fooCertCheckMonitor",
|
|
551
|
+
domain="www.one.example.com",
|
|
552
|
+
locations_privates=[foo_private_location.id],
|
|
553
|
+
certificate_expiration=10,
|
|
470
554
|
period="EVERY_6_HOURS",
|
|
471
555
|
status="ENABLED",
|
|
472
556
|
tags=[newrelic.synthetics.CertCheckMonitorTagArgs(
|
|
@@ -478,7 +562,7 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
478
562
|
|
|
479
563
|
## Import
|
|
480
564
|
|
|
481
|
-
|
|
565
|
+
A cert check monitor can be imported using its GUID, using the following command.
|
|
482
566
|
|
|
483
567
|
bash
|
|
484
568
|
|
|
@@ -508,6 +592,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
508
592
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
509
593
|
name: Optional[pulumi.Input[str]] = None,
|
|
510
594
|
period: Optional[pulumi.Input[str]] = None,
|
|
595
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
596
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
511
597
|
status: Optional[pulumi.Input[str]] = None,
|
|
512
598
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CertCheckMonitorTagArgs']]]]] = None,
|
|
513
599
|
__props__=None):
|
|
@@ -532,6 +618,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
532
618
|
if period is None and not opts.urn:
|
|
533
619
|
raise TypeError("Missing required property 'period'")
|
|
534
620
|
__props__.__dict__["period"] = period
|
|
621
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
622
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
535
623
|
if status is None and not opts.urn:
|
|
536
624
|
raise TypeError("Missing required property 'status'")
|
|
537
625
|
__props__.__dict__["status"] = status
|
|
@@ -555,6 +643,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
555
643
|
name: Optional[pulumi.Input[str]] = None,
|
|
556
644
|
period: Optional[pulumi.Input[str]] = None,
|
|
557
645
|
period_in_minutes: Optional[pulumi.Input[int]] = None,
|
|
646
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
647
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
558
648
|
status: Optional[pulumi.Input[str]] = None,
|
|
559
649
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CertCheckMonitorTagArgs']]]]] = None) -> 'CertCheckMonitor':
|
|
560
650
|
"""
|
|
@@ -572,6 +662,10 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
572
662
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
573
663
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
574
664
|
:param pulumi.Input[int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
665
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
666
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
667
|
+
|
|
668
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
575
669
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
576
670
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CertCheckMonitorTagArgs']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
577
671
|
"""
|
|
@@ -587,6 +681,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
587
681
|
__props__.__dict__["name"] = name
|
|
588
682
|
__props__.__dict__["period"] = period
|
|
589
683
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
684
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
685
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
590
686
|
__props__.__dict__["status"] = status
|
|
591
687
|
__props__.__dict__["tags"] = tags
|
|
592
688
|
return CertCheckMonitor(resource_name, opts=opts, __props__=__props__)
|
|
@@ -655,6 +751,24 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
655
751
|
"""
|
|
656
752
|
return pulumi.get(self, "period_in_minutes")
|
|
657
753
|
|
|
754
|
+
@property
|
|
755
|
+
@pulumi.getter(name="runtimeType")
|
|
756
|
+
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
757
|
+
"""
|
|
758
|
+
The runtime that the monitor will use to run jobs.
|
|
759
|
+
"""
|
|
760
|
+
return pulumi.get(self, "runtime_type")
|
|
761
|
+
|
|
762
|
+
@property
|
|
763
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
764
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
765
|
+
"""
|
|
766
|
+
The specific version of the runtime type selected.
|
|
767
|
+
|
|
768
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `NODE_API` and `16.10` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
769
|
+
"""
|
|
770
|
+
return pulumi.get(self, "runtime_type_version")
|
|
771
|
+
|
|
658
772
|
@property
|
|
659
773
|
@pulumi.getter
|
|
660
774
|
def status(self) -> pulumi.Output[str]:
|
|
@@ -24,6 +24,8 @@ class StepMonitorArgs:
|
|
|
24
24
|
location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]] = None,
|
|
25
25
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
26
26
|
name: Optional[pulumi.Input[str]] = None,
|
|
27
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
28
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
27
29
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None):
|
|
28
30
|
"""
|
|
29
31
|
The set of arguments for constructing a StepMonitor resource.
|
|
@@ -35,6 +37,10 @@ class StepMonitorArgs:
|
|
|
35
37
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
|
|
36
38
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Valid public locations are https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
37
39
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
40
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
41
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
42
|
+
|
|
43
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
38
44
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
39
45
|
"""
|
|
40
46
|
pulumi.set(__self__, "period", period)
|
|
@@ -50,6 +56,10 @@ class StepMonitorArgs:
|
|
|
50
56
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
51
57
|
if name is not None:
|
|
52
58
|
pulumi.set(__self__, "name", name)
|
|
59
|
+
if runtime_type is not None:
|
|
60
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
61
|
+
if runtime_type_version is not None:
|
|
62
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
53
63
|
if tags is not None:
|
|
54
64
|
pulumi.set(__self__, "tags", tags)
|
|
55
65
|
|
|
@@ -149,6 +159,32 @@ class StepMonitorArgs:
|
|
|
149
159
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
150
160
|
pulumi.set(self, "name", value)
|
|
151
161
|
|
|
162
|
+
@property
|
|
163
|
+
@pulumi.getter(name="runtimeType")
|
|
164
|
+
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
165
|
+
"""
|
|
166
|
+
The runtime that the monitor will use to run jobs.
|
|
167
|
+
"""
|
|
168
|
+
return pulumi.get(self, "runtime_type")
|
|
169
|
+
|
|
170
|
+
@runtime_type.setter
|
|
171
|
+
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
172
|
+
pulumi.set(self, "runtime_type", value)
|
|
173
|
+
|
|
174
|
+
@property
|
|
175
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
176
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
177
|
+
"""
|
|
178
|
+
The specific version of the runtime type selected.
|
|
179
|
+
|
|
180
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
181
|
+
"""
|
|
182
|
+
return pulumi.get(self, "runtime_type_version")
|
|
183
|
+
|
|
184
|
+
@runtime_type_version.setter
|
|
185
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
186
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
187
|
+
|
|
152
188
|
@property
|
|
153
189
|
@pulumi.getter
|
|
154
190
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]:
|
|
@@ -173,6 +209,8 @@ class _StepMonitorState:
|
|
|
173
209
|
name: Optional[pulumi.Input[str]] = None,
|
|
174
210
|
period: Optional[pulumi.Input[str]] = None,
|
|
175
211
|
period_in_minutes: Optional[pulumi.Input[int]] = None,
|
|
212
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
213
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
176
214
|
status: Optional[pulumi.Input[str]] = None,
|
|
177
215
|
steps: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]] = None,
|
|
178
216
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None):
|
|
@@ -186,6 +224,10 @@ class _StepMonitorState:
|
|
|
186
224
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
187
225
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
188
226
|
:param pulumi.Input[int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
227
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
228
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
229
|
+
|
|
230
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
189
231
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
190
232
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
191
233
|
:param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
@@ -206,6 +248,10 @@ class _StepMonitorState:
|
|
|
206
248
|
pulumi.set(__self__, "period", period)
|
|
207
249
|
if period_in_minutes is not None:
|
|
208
250
|
pulumi.set(__self__, "period_in_minutes", period_in_minutes)
|
|
251
|
+
if runtime_type is not None:
|
|
252
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
253
|
+
if runtime_type_version is not None:
|
|
254
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
209
255
|
if status is not None:
|
|
210
256
|
pulumi.set(__self__, "status", status)
|
|
211
257
|
if steps is not None:
|
|
@@ -309,6 +355,32 @@ class _StepMonitorState:
|
|
|
309
355
|
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
310
356
|
pulumi.set(self, "period_in_minutes", value)
|
|
311
357
|
|
|
358
|
+
@property
|
|
359
|
+
@pulumi.getter(name="runtimeType")
|
|
360
|
+
def runtime_type(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
"""
|
|
362
|
+
The runtime that the monitor will use to run jobs.
|
|
363
|
+
"""
|
|
364
|
+
return pulumi.get(self, "runtime_type")
|
|
365
|
+
|
|
366
|
+
@runtime_type.setter
|
|
367
|
+
def runtime_type(self, value: Optional[pulumi.Input[str]]):
|
|
368
|
+
pulumi.set(self, "runtime_type", value)
|
|
369
|
+
|
|
370
|
+
@property
|
|
371
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
372
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[str]]:
|
|
373
|
+
"""
|
|
374
|
+
The specific version of the runtime type selected.
|
|
375
|
+
|
|
376
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
377
|
+
"""
|
|
378
|
+
return pulumi.get(self, "runtime_type_version")
|
|
379
|
+
|
|
380
|
+
@runtime_type_version.setter
|
|
381
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[str]]):
|
|
382
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
383
|
+
|
|
312
384
|
@property
|
|
313
385
|
@pulumi.getter
|
|
314
386
|
def status(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -357,6 +429,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
357
429
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
358
430
|
name: Optional[pulumi.Input[str]] = None,
|
|
359
431
|
period: Optional[pulumi.Input[str]] = None,
|
|
432
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
433
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
360
434
|
status: Optional[pulumi.Input[str]] = None,
|
|
361
435
|
steps: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorStepArgs']]]]] = None,
|
|
362
436
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorTagArgs']]]]] = None,
|
|
@@ -371,13 +445,15 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
371
445
|
import pulumi
|
|
372
446
|
import pulumi_newrelic as newrelic
|
|
373
447
|
|
|
374
|
-
|
|
448
|
+
foo = newrelic.synthetics.StepMonitor("foo",
|
|
375
449
|
enable_screenshot_on_failure_and_script=True,
|
|
376
450
|
locations_publics=[
|
|
377
451
|
"US_EAST_1",
|
|
378
452
|
"US_EAST_2",
|
|
379
453
|
],
|
|
380
454
|
period="EVERY_6_HOURS",
|
|
455
|
+
runtime_type="CHROME_BROWSER",
|
|
456
|
+
runtime_type_version="100",
|
|
381
457
|
status="ENABLED",
|
|
382
458
|
steps=[newrelic.synthetics.StepMonitorStepArgs(
|
|
383
459
|
ordinal=0,
|
|
@@ -394,9 +470,42 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
394
470
|
|
|
395
471
|
## Additional Examples
|
|
396
472
|
|
|
473
|
+
### Create a monitor with a private location
|
|
474
|
+
|
|
475
|
+
The below example shows how you can define a private location and attach it to a monitor.
|
|
476
|
+
|
|
477
|
+
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
478
|
+
|
|
479
|
+
<!--Start PulumiCodeChooser -->
|
|
480
|
+
```python
|
|
481
|
+
import pulumi
|
|
482
|
+
import pulumi_newrelic as newrelic
|
|
483
|
+
|
|
484
|
+
foo_private_location = newrelic.synthetics.PrivateLocation("fooPrivateLocation",
|
|
485
|
+
description="Sample Private Location Description",
|
|
486
|
+
verified_script_execution=True)
|
|
487
|
+
foo_step_monitor = newrelic.synthetics.StepMonitor("fooStepMonitor",
|
|
488
|
+
period="EVERY_6_HOURS",
|
|
489
|
+
status="ENABLED",
|
|
490
|
+
location_privates=[newrelic.synthetics.StepMonitorLocationPrivateArgs(
|
|
491
|
+
guid=foo_private_location.id,
|
|
492
|
+
vse_password="secret",
|
|
493
|
+
)],
|
|
494
|
+
steps=[newrelic.synthetics.StepMonitorStepArgs(
|
|
495
|
+
ordinal=0,
|
|
496
|
+
type="NAVIGATE",
|
|
497
|
+
values=["https://google.com"],
|
|
498
|
+
)],
|
|
499
|
+
tags=[newrelic.synthetics.StepMonitorTagArgs(
|
|
500
|
+
key="some_key",
|
|
501
|
+
values=["some_value"],
|
|
502
|
+
)])
|
|
503
|
+
```
|
|
504
|
+
<!--End PulumiCodeChooser -->
|
|
505
|
+
|
|
397
506
|
## Import
|
|
398
507
|
|
|
399
|
-
|
|
508
|
+
A step monitor can be imported using its GUID, using the following command.
|
|
400
509
|
|
|
401
510
|
bash
|
|
402
511
|
|
|
@@ -412,6 +521,10 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
412
521
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from. Valid public locations are https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
413
522
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
414
523
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
524
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
525
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
526
|
+
|
|
527
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
415
528
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
416
529
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorStepArgs']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
417
530
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorTagArgs']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
@@ -432,13 +545,15 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
432
545
|
import pulumi
|
|
433
546
|
import pulumi_newrelic as newrelic
|
|
434
547
|
|
|
435
|
-
|
|
548
|
+
foo = newrelic.synthetics.StepMonitor("foo",
|
|
436
549
|
enable_screenshot_on_failure_and_script=True,
|
|
437
550
|
locations_publics=[
|
|
438
551
|
"US_EAST_1",
|
|
439
552
|
"US_EAST_2",
|
|
440
553
|
],
|
|
441
554
|
period="EVERY_6_HOURS",
|
|
555
|
+
runtime_type="CHROME_BROWSER",
|
|
556
|
+
runtime_type_version="100",
|
|
442
557
|
status="ENABLED",
|
|
443
558
|
steps=[newrelic.synthetics.StepMonitorStepArgs(
|
|
444
559
|
ordinal=0,
|
|
@@ -455,9 +570,42 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
455
570
|
|
|
456
571
|
## Additional Examples
|
|
457
572
|
|
|
573
|
+
### Create a monitor with a private location
|
|
574
|
+
|
|
575
|
+
The below example shows how you can define a private location and attach it to a monitor.
|
|
576
|
+
|
|
577
|
+
> **NOTE:** It can take up to 10 minutes for a private location to become available.
|
|
578
|
+
|
|
579
|
+
<!--Start PulumiCodeChooser -->
|
|
580
|
+
```python
|
|
581
|
+
import pulumi
|
|
582
|
+
import pulumi_newrelic as newrelic
|
|
583
|
+
|
|
584
|
+
foo_private_location = newrelic.synthetics.PrivateLocation("fooPrivateLocation",
|
|
585
|
+
description="Sample Private Location Description",
|
|
586
|
+
verified_script_execution=True)
|
|
587
|
+
foo_step_monitor = newrelic.synthetics.StepMonitor("fooStepMonitor",
|
|
588
|
+
period="EVERY_6_HOURS",
|
|
589
|
+
status="ENABLED",
|
|
590
|
+
location_privates=[newrelic.synthetics.StepMonitorLocationPrivateArgs(
|
|
591
|
+
guid=foo_private_location.id,
|
|
592
|
+
vse_password="secret",
|
|
593
|
+
)],
|
|
594
|
+
steps=[newrelic.synthetics.StepMonitorStepArgs(
|
|
595
|
+
ordinal=0,
|
|
596
|
+
type="NAVIGATE",
|
|
597
|
+
values=["https://google.com"],
|
|
598
|
+
)],
|
|
599
|
+
tags=[newrelic.synthetics.StepMonitorTagArgs(
|
|
600
|
+
key="some_key",
|
|
601
|
+
values=["some_value"],
|
|
602
|
+
)])
|
|
603
|
+
```
|
|
604
|
+
<!--End PulumiCodeChooser -->
|
|
605
|
+
|
|
458
606
|
## Import
|
|
459
607
|
|
|
460
|
-
|
|
608
|
+
A step monitor can be imported using its GUID, using the following command.
|
|
461
609
|
|
|
462
610
|
bash
|
|
463
611
|
|
|
@@ -486,6 +634,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
486
634
|
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
487
635
|
name: Optional[pulumi.Input[str]] = None,
|
|
488
636
|
period: Optional[pulumi.Input[str]] = None,
|
|
637
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
638
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
489
639
|
status: Optional[pulumi.Input[str]] = None,
|
|
490
640
|
steps: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorStepArgs']]]]] = None,
|
|
491
641
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorTagArgs']]]]] = None,
|
|
@@ -506,6 +656,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
506
656
|
if period is None and not opts.urn:
|
|
507
657
|
raise TypeError("Missing required property 'period'")
|
|
508
658
|
__props__.__dict__["period"] = period
|
|
659
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
660
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
509
661
|
if status is None and not opts.urn:
|
|
510
662
|
raise TypeError("Missing required property 'status'")
|
|
511
663
|
__props__.__dict__["status"] = status
|
|
@@ -533,6 +685,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
533
685
|
name: Optional[pulumi.Input[str]] = None,
|
|
534
686
|
period: Optional[pulumi.Input[str]] = None,
|
|
535
687
|
period_in_minutes: Optional[pulumi.Input[int]] = None,
|
|
688
|
+
runtime_type: Optional[pulumi.Input[str]] = None,
|
|
689
|
+
runtime_type_version: Optional[pulumi.Input[str]] = None,
|
|
536
690
|
status: Optional[pulumi.Input[str]] = None,
|
|
537
691
|
steps: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorStepArgs']]]]] = None,
|
|
538
692
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorTagArgs']]]]] = None) -> 'StepMonitor':
|
|
@@ -551,6 +705,10 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
551
705
|
:param pulumi.Input[str] name: The name for the monitor.
|
|
552
706
|
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE, EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES, EVERY_30_MINUTES, EVERY_HOUR, EVERY_6_HOURS, EVERY_12_HOURS, or EVERY_DAY.
|
|
553
707
|
:param pulumi.Input[int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
708
|
+
:param pulumi.Input[str] runtime_type: The runtime that the monitor will use to run jobs.
|
|
709
|
+
:param pulumi.Input[str] runtime_type_version: The specific version of the runtime type selected.
|
|
710
|
+
|
|
711
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
554
712
|
:param pulumi.Input[str] status: The monitor status (ENABLED or DISABLED).
|
|
555
713
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorStepArgs']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
|
|
556
714
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StepMonitorTagArgs']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
|
|
@@ -567,6 +725,8 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
567
725
|
__props__.__dict__["name"] = name
|
|
568
726
|
__props__.__dict__["period"] = period
|
|
569
727
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
728
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
729
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
570
730
|
__props__.__dict__["status"] = status
|
|
571
731
|
__props__.__dict__["steps"] = steps
|
|
572
732
|
__props__.__dict__["tags"] = tags
|
|
@@ -636,6 +796,24 @@ class StepMonitor(pulumi.CustomResource):
|
|
|
636
796
|
"""
|
|
637
797
|
return pulumi.get(self, "period_in_minutes")
|
|
638
798
|
|
|
799
|
+
@property
|
|
800
|
+
@pulumi.getter(name="runtimeType")
|
|
801
|
+
def runtime_type(self) -> pulumi.Output[Optional[str]]:
|
|
802
|
+
"""
|
|
803
|
+
The runtime that the monitor will use to run jobs.
|
|
804
|
+
"""
|
|
805
|
+
return pulumi.get(self, "runtime_type")
|
|
806
|
+
|
|
807
|
+
@property
|
|
808
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
809
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[str]]:
|
|
810
|
+
"""
|
|
811
|
+
The specific version of the runtime type selected.
|
|
812
|
+
|
|
813
|
+
> **NOTE:** Currently, the values of `runtime_type` and `runtime_type_version` supported by this resource are `CHROME_BROWSER` and `100` respectively. In order to run the monitor in the new runtime, both `runtime_type` and `runtime_type_version` need to be specified; however, specifying neither of these attributes would set this monitor to use the legacy runtime. It may also be noted that the runtime opted for would only be effective with private locations. For public locations, all traffic has been shifted to the new runtime, irrespective of the selection made.
|
|
814
|
+
"""
|
|
815
|
+
return pulumi.get(self, "runtime_type_version")
|
|
816
|
+
|
|
639
817
|
@property
|
|
640
818
|
@pulumi.getter
|
|
641
819
|
def status(self) -> pulumi.Output[str]:
|