pulumi-azure-native 3.1.0a1744041749__py3-none-any.whl → 3.1.0a1744104520__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-azure-native might be problematic. Click here for more details.
- pulumi_azure_native/__init__.py +2 -0
- pulumi_azure_native/monitor/__init__.py +4 -0
- pulumi_azure_native/monitor/_enums.py +54 -0
- pulumi_azure_native/monitor/_inputs.py +1469 -305
- pulumi_azure_native/monitor/action_group.py +9 -9
- pulumi_azure_native/monitor/activity_log_alert.py +388 -0
- pulumi_azure_native/monitor/get_action_group.py +2 -2
- pulumi_azure_native/monitor/get_activity_log_alert.py +231 -0
- pulumi_azure_native/monitor/get_metric_alert.py +343 -0
- pulumi_azure_native/monitor/get_private_endpoint_connection.py +4 -0
- pulumi_azure_native/monitor/get_private_link_scope.py +4 -0
- pulumi_azure_native/monitor/get_private_link_scoped_resource.py +4 -0
- pulumi_azure_native/monitor/metric_alert.py +578 -0
- pulumi_azure_native/monitor/outputs.py +1162 -207
- pulumi_azure_native/monitor/private_endpoint_connection.py +4 -0
- pulumi_azure_native/monitor/private_link_scope.py +4 -0
- pulumi_azure_native/monitor/private_link_scoped_resource.py +4 -0
- pulumi_azure_native/pulumi-plugin.json +1 -1
- {pulumi_azure_native-3.1.0a1744041749.dist-info → pulumi_azure_native-3.1.0a1744104520.dist-info}/METADATA +1 -1
- {pulumi_azure_native-3.1.0a1744041749.dist-info → pulumi_azure_native-3.1.0a1744104520.dist-info}/RECORD +22 -18
- {pulumi_azure_native-3.1.0a1744041749.dist-info → pulumi_azure_native-3.1.0a1744104520.dist-info}/WHEEL +0 -0
- {pulumi_azure_native-3.1.0a1744041749.dist-info → pulumi_azure_native-3.1.0a1744104520.dist-info}/top_level.txt +0 -0
|
@@ -20,8 +20,18 @@ __all__ = [
|
|
|
20
20
|
'AccessModeSettingsExclusionArgsDict',
|
|
21
21
|
'AccessModeSettingsArgs',
|
|
22
22
|
'AccessModeSettingsArgsDict',
|
|
23
|
+
'ActionGroupArgs',
|
|
24
|
+
'ActionGroupArgsDict',
|
|
25
|
+
'ActionListArgs',
|
|
26
|
+
'ActionListArgsDict',
|
|
23
27
|
'ActionsArgs',
|
|
24
28
|
'ActionsArgsDict',
|
|
29
|
+
'AlertRuleAllOfConditionArgs',
|
|
30
|
+
'AlertRuleAllOfConditionArgsDict',
|
|
31
|
+
'AlertRuleAnyOfOrLeafConditionArgs',
|
|
32
|
+
'AlertRuleAnyOfOrLeafConditionArgsDict',
|
|
33
|
+
'AlertRuleLeafConditionArgs',
|
|
34
|
+
'AlertRuleLeafConditionArgsDict',
|
|
25
35
|
'ArmRoleReceiverArgs',
|
|
26
36
|
'ArmRoleReceiverArgsDict',
|
|
27
37
|
'AutomationRunbookReceiverArgs',
|
|
@@ -72,6 +82,10 @@ __all__ = [
|
|
|
72
82
|
'DestinationsSpecAzureMonitorMetricsArgsDict',
|
|
73
83
|
'DimensionArgs',
|
|
74
84
|
'DimensionArgsDict',
|
|
85
|
+
'DynamicMetricCriteriaArgs',
|
|
86
|
+
'DynamicMetricCriteriaArgsDict',
|
|
87
|
+
'DynamicThresholdFailingPeriodsArgs',
|
|
88
|
+
'DynamicThresholdFailingPeriodsArgsDict',
|
|
75
89
|
'EmailNotificationArgs',
|
|
76
90
|
'EmailNotificationArgsDict',
|
|
77
91
|
'EmailReceiverArgs',
|
|
@@ -118,6 +132,16 @@ __all__ = [
|
|
|
118
132
|
'ManagedServiceIdentityArgsDict',
|
|
119
133
|
'ManagementGroupLogSettingsArgs',
|
|
120
134
|
'ManagementGroupLogSettingsArgsDict',
|
|
135
|
+
'MetricAlertActionArgs',
|
|
136
|
+
'MetricAlertActionArgsDict',
|
|
137
|
+
'MetricAlertMultipleResourceMultipleMetricCriteriaArgs',
|
|
138
|
+
'MetricAlertMultipleResourceMultipleMetricCriteriaArgsDict',
|
|
139
|
+
'MetricAlertSingleResourceMultipleMetricCriteriaArgs',
|
|
140
|
+
'MetricAlertSingleResourceMultipleMetricCriteriaArgsDict',
|
|
141
|
+
'MetricCriteriaArgs',
|
|
142
|
+
'MetricCriteriaArgsDict',
|
|
143
|
+
'MetricDimensionArgs',
|
|
144
|
+
'MetricDimensionArgsDict',
|
|
121
145
|
'MetricSettingsArgs',
|
|
122
146
|
'MetricSettingsArgsDict',
|
|
123
147
|
'MetricTriggerArgs',
|
|
@@ -204,6 +228,8 @@ __all__ = [
|
|
|
204
228
|
'WebhookNotificationArgsDict',
|
|
205
229
|
'WebhookReceiverArgs',
|
|
206
230
|
'WebhookReceiverArgsDict',
|
|
231
|
+
'WebtestLocationAvailabilityCriteriaArgs',
|
|
232
|
+
'WebtestLocationAvailabilityCriteriaArgsDict',
|
|
207
233
|
'WindowsEventLogDataSourceArgs',
|
|
208
234
|
'WindowsEventLogDataSourceArgsDict',
|
|
209
235
|
'WindowsFirewallLogsDataSourceArgs',
|
|
@@ -362,6 +388,97 @@ class AccessModeSettingsArgs:
|
|
|
362
388
|
pulumi.set(self, "exclusions", value)
|
|
363
389
|
|
|
364
390
|
|
|
391
|
+
if not MYPY:
|
|
392
|
+
class ActionGroupArgsDict(TypedDict):
|
|
393
|
+
"""
|
|
394
|
+
A pointer to an Azure Action Group.
|
|
395
|
+
"""
|
|
396
|
+
action_group_id: pulumi.Input[str]
|
|
397
|
+
"""
|
|
398
|
+
The resource ID of the Action Group. This cannot be null or empty.
|
|
399
|
+
"""
|
|
400
|
+
webhook_properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
401
|
+
"""
|
|
402
|
+
the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
|
|
403
|
+
"""
|
|
404
|
+
elif False:
|
|
405
|
+
ActionGroupArgsDict: TypeAlias = Mapping[str, Any]
|
|
406
|
+
|
|
407
|
+
@pulumi.input_type
|
|
408
|
+
class ActionGroupArgs:
|
|
409
|
+
def __init__(__self__, *,
|
|
410
|
+
action_group_id: pulumi.Input[str],
|
|
411
|
+
webhook_properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
412
|
+
"""
|
|
413
|
+
A pointer to an Azure Action Group.
|
|
414
|
+
:param pulumi.Input[str] action_group_id: The resource ID of the Action Group. This cannot be null or empty.
|
|
415
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] webhook_properties: the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
|
|
416
|
+
"""
|
|
417
|
+
pulumi.set(__self__, "action_group_id", action_group_id)
|
|
418
|
+
if webhook_properties is not None:
|
|
419
|
+
pulumi.set(__self__, "webhook_properties", webhook_properties)
|
|
420
|
+
|
|
421
|
+
@property
|
|
422
|
+
@pulumi.getter(name="actionGroupId")
|
|
423
|
+
def action_group_id(self) -> pulumi.Input[str]:
|
|
424
|
+
"""
|
|
425
|
+
The resource ID of the Action Group. This cannot be null or empty.
|
|
426
|
+
"""
|
|
427
|
+
return pulumi.get(self, "action_group_id")
|
|
428
|
+
|
|
429
|
+
@action_group_id.setter
|
|
430
|
+
def action_group_id(self, value: pulumi.Input[str]):
|
|
431
|
+
pulumi.set(self, "action_group_id", value)
|
|
432
|
+
|
|
433
|
+
@property
|
|
434
|
+
@pulumi.getter(name="webhookProperties")
|
|
435
|
+
def webhook_properties(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
436
|
+
"""
|
|
437
|
+
the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
|
|
438
|
+
"""
|
|
439
|
+
return pulumi.get(self, "webhook_properties")
|
|
440
|
+
|
|
441
|
+
@webhook_properties.setter
|
|
442
|
+
def webhook_properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
443
|
+
pulumi.set(self, "webhook_properties", value)
|
|
444
|
+
|
|
445
|
+
|
|
446
|
+
if not MYPY:
|
|
447
|
+
class ActionListArgsDict(TypedDict):
|
|
448
|
+
"""
|
|
449
|
+
A list of Activity Log Alert rule actions.
|
|
450
|
+
"""
|
|
451
|
+
action_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionGroupArgsDict']]]]
|
|
452
|
+
"""
|
|
453
|
+
The list of the Action Groups.
|
|
454
|
+
"""
|
|
455
|
+
elif False:
|
|
456
|
+
ActionListArgsDict: TypeAlias = Mapping[str, Any]
|
|
457
|
+
|
|
458
|
+
@pulumi.input_type
|
|
459
|
+
class ActionListArgs:
|
|
460
|
+
def __init__(__self__, *,
|
|
461
|
+
action_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ActionGroupArgs']]]] = None):
|
|
462
|
+
"""
|
|
463
|
+
A list of Activity Log Alert rule actions.
|
|
464
|
+
:param pulumi.Input[Sequence[pulumi.Input['ActionGroupArgs']]] action_groups: The list of the Action Groups.
|
|
465
|
+
"""
|
|
466
|
+
if action_groups is not None:
|
|
467
|
+
pulumi.set(__self__, "action_groups", action_groups)
|
|
468
|
+
|
|
469
|
+
@property
|
|
470
|
+
@pulumi.getter(name="actionGroups")
|
|
471
|
+
def action_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionGroupArgs']]]]:
|
|
472
|
+
"""
|
|
473
|
+
The list of the Action Groups.
|
|
474
|
+
"""
|
|
475
|
+
return pulumi.get(self, "action_groups")
|
|
476
|
+
|
|
477
|
+
@action_groups.setter
|
|
478
|
+
def action_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionGroupArgs']]]]):
|
|
479
|
+
pulumi.set(self, "action_groups", value)
|
|
480
|
+
|
|
481
|
+
|
|
365
482
|
if not MYPY:
|
|
366
483
|
class ActionsArgsDict(TypedDict):
|
|
367
484
|
"""
|
|
@@ -438,6 +555,234 @@ class ActionsArgs:
|
|
|
438
555
|
pulumi.set(self, "custom_properties", value)
|
|
439
556
|
|
|
440
557
|
|
|
558
|
+
if not MYPY:
|
|
559
|
+
class AlertRuleAllOfConditionArgsDict(TypedDict):
|
|
560
|
+
"""
|
|
561
|
+
An Activity Log Alert rule condition that is met when all its member conditions are met.
|
|
562
|
+
"""
|
|
563
|
+
all_of: pulumi.Input[Sequence[pulumi.Input['AlertRuleAnyOfOrLeafConditionArgsDict']]]
|
|
564
|
+
"""
|
|
565
|
+
The list of Activity Log Alert rule conditions.
|
|
566
|
+
"""
|
|
567
|
+
elif False:
|
|
568
|
+
AlertRuleAllOfConditionArgsDict: TypeAlias = Mapping[str, Any]
|
|
569
|
+
|
|
570
|
+
@pulumi.input_type
|
|
571
|
+
class AlertRuleAllOfConditionArgs:
|
|
572
|
+
def __init__(__self__, *,
|
|
573
|
+
all_of: pulumi.Input[Sequence[pulumi.Input['AlertRuleAnyOfOrLeafConditionArgs']]]):
|
|
574
|
+
"""
|
|
575
|
+
An Activity Log Alert rule condition that is met when all its member conditions are met.
|
|
576
|
+
:param pulumi.Input[Sequence[pulumi.Input['AlertRuleAnyOfOrLeafConditionArgs']]] all_of: The list of Activity Log Alert rule conditions.
|
|
577
|
+
"""
|
|
578
|
+
pulumi.set(__self__, "all_of", all_of)
|
|
579
|
+
|
|
580
|
+
@property
|
|
581
|
+
@pulumi.getter(name="allOf")
|
|
582
|
+
def all_of(self) -> pulumi.Input[Sequence[pulumi.Input['AlertRuleAnyOfOrLeafConditionArgs']]]:
|
|
583
|
+
"""
|
|
584
|
+
The list of Activity Log Alert rule conditions.
|
|
585
|
+
"""
|
|
586
|
+
return pulumi.get(self, "all_of")
|
|
587
|
+
|
|
588
|
+
@all_of.setter
|
|
589
|
+
def all_of(self, value: pulumi.Input[Sequence[pulumi.Input['AlertRuleAnyOfOrLeafConditionArgs']]]):
|
|
590
|
+
pulumi.set(self, "all_of", value)
|
|
591
|
+
|
|
592
|
+
|
|
593
|
+
if not MYPY:
|
|
594
|
+
class AlertRuleAnyOfOrLeafConditionArgsDict(TypedDict):
|
|
595
|
+
"""
|
|
596
|
+
An Activity Log Alert rule condition that is met when all its member conditions are met.
|
|
597
|
+
Each condition can be of one of the following types:
|
|
598
|
+
__Important__: Each type has its unique subset of properties. Properties from different types CANNOT exist in one condition.
|
|
599
|
+
* __Leaf Condition -__ must contain 'field' and either 'equals' or 'containsAny'.
|
|
600
|
+
_Please note, 'anyOf' should __not__ be set in a Leaf Condition._
|
|
601
|
+
* __AnyOf Condition -__ must contain __only__ 'anyOf' (which is an array of Leaf Conditions).
|
|
602
|
+
_Please note, 'field', 'equals' and 'containsAny' should __not__ be set in an AnyOf Condition._
|
|
603
|
+
"""
|
|
604
|
+
any_of: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertRuleLeafConditionArgsDict']]]]
|
|
605
|
+
"""
|
|
606
|
+
An Activity Log Alert rule condition that is met when at least one of its member leaf conditions are met.
|
|
607
|
+
"""
|
|
608
|
+
contains_any: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
609
|
+
"""
|
|
610
|
+
The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
611
|
+
"""
|
|
612
|
+
equals: NotRequired[pulumi.Input[str]]
|
|
613
|
+
"""
|
|
614
|
+
The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
615
|
+
"""
|
|
616
|
+
field: NotRequired[pulumi.Input[str]]
|
|
617
|
+
"""
|
|
618
|
+
The name of the Activity Log event's field that this condition will examine.
|
|
619
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
620
|
+
"""
|
|
621
|
+
elif False:
|
|
622
|
+
AlertRuleAnyOfOrLeafConditionArgsDict: TypeAlias = Mapping[str, Any]
|
|
623
|
+
|
|
624
|
+
@pulumi.input_type
|
|
625
|
+
class AlertRuleAnyOfOrLeafConditionArgs:
|
|
626
|
+
def __init__(__self__, *,
|
|
627
|
+
any_of: Optional[pulumi.Input[Sequence[pulumi.Input['AlertRuleLeafConditionArgs']]]] = None,
|
|
628
|
+
contains_any: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
629
|
+
equals: Optional[pulumi.Input[str]] = None,
|
|
630
|
+
field: Optional[pulumi.Input[str]] = None):
|
|
631
|
+
"""
|
|
632
|
+
An Activity Log Alert rule condition that is met when all its member conditions are met.
|
|
633
|
+
Each condition can be of one of the following types:
|
|
634
|
+
__Important__: Each type has its unique subset of properties. Properties from different types CANNOT exist in one condition.
|
|
635
|
+
* __Leaf Condition -__ must contain 'field' and either 'equals' or 'containsAny'.
|
|
636
|
+
_Please note, 'anyOf' should __not__ be set in a Leaf Condition._
|
|
637
|
+
* __AnyOf Condition -__ must contain __only__ 'anyOf' (which is an array of Leaf Conditions).
|
|
638
|
+
_Please note, 'field', 'equals' and 'containsAny' should __not__ be set in an AnyOf Condition._
|
|
639
|
+
|
|
640
|
+
:param pulumi.Input[Sequence[pulumi.Input['AlertRuleLeafConditionArgs']]] any_of: An Activity Log Alert rule condition that is met when at least one of its member leaf conditions are met.
|
|
641
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] contains_any: The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
642
|
+
:param pulumi.Input[str] equals: The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
643
|
+
:param pulumi.Input[str] field: The name of the Activity Log event's field that this condition will examine.
|
|
644
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
645
|
+
"""
|
|
646
|
+
if any_of is not None:
|
|
647
|
+
pulumi.set(__self__, "any_of", any_of)
|
|
648
|
+
if contains_any is not None:
|
|
649
|
+
pulumi.set(__self__, "contains_any", contains_any)
|
|
650
|
+
if equals is not None:
|
|
651
|
+
pulumi.set(__self__, "equals", equals)
|
|
652
|
+
if field is not None:
|
|
653
|
+
pulumi.set(__self__, "field", field)
|
|
654
|
+
|
|
655
|
+
@property
|
|
656
|
+
@pulumi.getter(name="anyOf")
|
|
657
|
+
def any_of(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertRuleLeafConditionArgs']]]]:
|
|
658
|
+
"""
|
|
659
|
+
An Activity Log Alert rule condition that is met when at least one of its member leaf conditions are met.
|
|
660
|
+
"""
|
|
661
|
+
return pulumi.get(self, "any_of")
|
|
662
|
+
|
|
663
|
+
@any_of.setter
|
|
664
|
+
def any_of(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertRuleLeafConditionArgs']]]]):
|
|
665
|
+
pulumi.set(self, "any_of", value)
|
|
666
|
+
|
|
667
|
+
@property
|
|
668
|
+
@pulumi.getter(name="containsAny")
|
|
669
|
+
def contains_any(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
670
|
+
"""
|
|
671
|
+
The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
672
|
+
"""
|
|
673
|
+
return pulumi.get(self, "contains_any")
|
|
674
|
+
|
|
675
|
+
@contains_any.setter
|
|
676
|
+
def contains_any(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
677
|
+
pulumi.set(self, "contains_any", value)
|
|
678
|
+
|
|
679
|
+
@property
|
|
680
|
+
@pulumi.getter
|
|
681
|
+
def equals(self) -> Optional[pulumi.Input[str]]:
|
|
682
|
+
"""
|
|
683
|
+
The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
684
|
+
"""
|
|
685
|
+
return pulumi.get(self, "equals")
|
|
686
|
+
|
|
687
|
+
@equals.setter
|
|
688
|
+
def equals(self, value: Optional[pulumi.Input[str]]):
|
|
689
|
+
pulumi.set(self, "equals", value)
|
|
690
|
+
|
|
691
|
+
@property
|
|
692
|
+
@pulumi.getter
|
|
693
|
+
def field(self) -> Optional[pulumi.Input[str]]:
|
|
694
|
+
"""
|
|
695
|
+
The name of the Activity Log event's field that this condition will examine.
|
|
696
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
697
|
+
"""
|
|
698
|
+
return pulumi.get(self, "field")
|
|
699
|
+
|
|
700
|
+
@field.setter
|
|
701
|
+
def field(self, value: Optional[pulumi.Input[str]]):
|
|
702
|
+
pulumi.set(self, "field", value)
|
|
703
|
+
|
|
704
|
+
|
|
705
|
+
if not MYPY:
|
|
706
|
+
class AlertRuleLeafConditionArgsDict(TypedDict):
|
|
707
|
+
"""
|
|
708
|
+
An Activity Log Alert rule condition that is met by comparing the field and value of an Activity Log event.
|
|
709
|
+
This condition must contain 'field' and either 'equals' or 'containsAny'.
|
|
710
|
+
"""
|
|
711
|
+
contains_any: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
712
|
+
"""
|
|
713
|
+
The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
714
|
+
"""
|
|
715
|
+
equals: NotRequired[pulumi.Input[str]]
|
|
716
|
+
"""
|
|
717
|
+
The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
718
|
+
"""
|
|
719
|
+
field: NotRequired[pulumi.Input[str]]
|
|
720
|
+
"""
|
|
721
|
+
The name of the Activity Log event's field that this condition will examine.
|
|
722
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
723
|
+
"""
|
|
724
|
+
elif False:
|
|
725
|
+
AlertRuleLeafConditionArgsDict: TypeAlias = Mapping[str, Any]
|
|
726
|
+
|
|
727
|
+
@pulumi.input_type
|
|
728
|
+
class AlertRuleLeafConditionArgs:
|
|
729
|
+
def __init__(__self__, *,
|
|
730
|
+
contains_any: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
731
|
+
equals: Optional[pulumi.Input[str]] = None,
|
|
732
|
+
field: Optional[pulumi.Input[str]] = None):
|
|
733
|
+
"""
|
|
734
|
+
An Activity Log Alert rule condition that is met by comparing the field and value of an Activity Log event.
|
|
735
|
+
This condition must contain 'field' and either 'equals' or 'containsAny'.
|
|
736
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] contains_any: The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
737
|
+
:param pulumi.Input[str] equals: The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
738
|
+
:param pulumi.Input[str] field: The name of the Activity Log event's field that this condition will examine.
|
|
739
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
740
|
+
"""
|
|
741
|
+
if contains_any is not None:
|
|
742
|
+
pulumi.set(__self__, "contains_any", contains_any)
|
|
743
|
+
if equals is not None:
|
|
744
|
+
pulumi.set(__self__, "equals", equals)
|
|
745
|
+
if field is not None:
|
|
746
|
+
pulumi.set(__self__, "field", field)
|
|
747
|
+
|
|
748
|
+
@property
|
|
749
|
+
@pulumi.getter(name="containsAny")
|
|
750
|
+
def contains_any(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
751
|
+
"""
|
|
752
|
+
The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
|
|
753
|
+
"""
|
|
754
|
+
return pulumi.get(self, "contains_any")
|
|
755
|
+
|
|
756
|
+
@contains_any.setter
|
|
757
|
+
def contains_any(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
758
|
+
pulumi.set(self, "contains_any", value)
|
|
759
|
+
|
|
760
|
+
@property
|
|
761
|
+
@pulumi.getter
|
|
762
|
+
def equals(self) -> Optional[pulumi.Input[str]]:
|
|
763
|
+
"""
|
|
764
|
+
The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
|
|
765
|
+
"""
|
|
766
|
+
return pulumi.get(self, "equals")
|
|
767
|
+
|
|
768
|
+
@equals.setter
|
|
769
|
+
def equals(self, value: Optional[pulumi.Input[str]]):
|
|
770
|
+
pulumi.set(self, "equals", value)
|
|
771
|
+
|
|
772
|
+
@property
|
|
773
|
+
@pulumi.getter
|
|
774
|
+
def field(self) -> Optional[pulumi.Input[str]]:
|
|
775
|
+
"""
|
|
776
|
+
The name of the Activity Log event's field that this condition will examine.
|
|
777
|
+
The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
|
|
778
|
+
"""
|
|
779
|
+
return pulumi.get(self, "field")
|
|
780
|
+
|
|
781
|
+
@field.setter
|
|
782
|
+
def field(self, value: Optional[pulumi.Input[str]]):
|
|
783
|
+
pulumi.set(self, "field", value)
|
|
784
|
+
|
|
785
|
+
|
|
441
786
|
if not MYPY:
|
|
442
787
|
class ArmRoleReceiverArgsDict(TypedDict):
|
|
443
788
|
"""
|
|
@@ -2717,131 +3062,417 @@ class DimensionArgs:
|
|
|
2717
3062
|
|
|
2718
3063
|
|
|
2719
3064
|
if not MYPY:
|
|
2720
|
-
class
|
|
3065
|
+
class DynamicMetricCriteriaArgsDict(TypedDict):
|
|
2721
3066
|
"""
|
|
2722
|
-
|
|
3067
|
+
Criterion for dynamic threshold.
|
|
2723
3068
|
"""
|
|
2724
|
-
|
|
3069
|
+
alert_sensitivity: pulumi.Input[Union[str, 'DynamicThresholdSensitivity']]
|
|
2725
3070
|
"""
|
|
2726
|
-
|
|
3071
|
+
The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
|
|
2727
3072
|
"""
|
|
2728
|
-
|
|
3073
|
+
criterion_type: pulumi.Input[str]
|
|
2729
3074
|
"""
|
|
2730
|
-
|
|
3075
|
+
Specifies the type of threshold criteria
|
|
3076
|
+
Expected value is 'DynamicThresholdCriterion'.
|
|
2731
3077
|
"""
|
|
2732
|
-
|
|
3078
|
+
failing_periods: pulumi.Input['DynamicThresholdFailingPeriodsArgsDict']
|
|
2733
3079
|
"""
|
|
2734
|
-
|
|
3080
|
+
The minimum number of violations required within the selected lookback time window required to raise an alert.
|
|
2735
3081
|
"""
|
|
2736
|
-
|
|
2737
|
-
EmailNotificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2738
|
-
|
|
2739
|
-
@pulumi.input_type
|
|
2740
|
-
class EmailNotificationArgs:
|
|
2741
|
-
def __init__(__self__, *,
|
|
2742
|
-
custom_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2743
|
-
send_to_subscription_administrator: Optional[pulumi.Input[bool]] = None,
|
|
2744
|
-
send_to_subscription_co_administrators: Optional[pulumi.Input[bool]] = None):
|
|
3082
|
+
metric_name: pulumi.Input[str]
|
|
2745
3083
|
"""
|
|
2746
|
-
|
|
2747
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
2748
|
-
:param pulumi.Input[bool] send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
|
|
2749
|
-
:param pulumi.Input[bool] send_to_subscription_co_administrators: a value indicating whether to send email to subscription co-administrators.
|
|
3084
|
+
Name of the metric.
|
|
2750
3085
|
"""
|
|
2751
|
-
|
|
2752
|
-
pulumi.set(__self__, "custom_emails", custom_emails)
|
|
2753
|
-
if send_to_subscription_administrator is None:
|
|
2754
|
-
send_to_subscription_administrator = False
|
|
2755
|
-
if send_to_subscription_administrator is not None:
|
|
2756
|
-
pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
|
|
2757
|
-
if send_to_subscription_co_administrators is None:
|
|
2758
|
-
send_to_subscription_co_administrators = False
|
|
2759
|
-
if send_to_subscription_co_administrators is not None:
|
|
2760
|
-
pulumi.set(__self__, "send_to_subscription_co_administrators", send_to_subscription_co_administrators)
|
|
2761
|
-
|
|
2762
|
-
@property
|
|
2763
|
-
@pulumi.getter(name="customEmails")
|
|
2764
|
-
def custom_emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3086
|
+
name: pulumi.Input[str]
|
|
2765
3087
|
"""
|
|
2766
|
-
|
|
3088
|
+
Name of the criteria.
|
|
2767
3089
|
"""
|
|
2768
|
-
|
|
2769
|
-
|
|
2770
|
-
@custom_emails.setter
|
|
2771
|
-
def custom_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2772
|
-
pulumi.set(self, "custom_emails", value)
|
|
2773
|
-
|
|
2774
|
-
@property
|
|
2775
|
-
@pulumi.getter(name="sendToSubscriptionAdministrator")
|
|
2776
|
-
def send_to_subscription_administrator(self) -> Optional[pulumi.Input[bool]]:
|
|
3090
|
+
operator: pulumi.Input[Union[str, 'DynamicThresholdOperator']]
|
|
2777
3091
|
"""
|
|
2778
|
-
|
|
3092
|
+
The operator used to compare the metric value against the threshold.
|
|
2779
3093
|
"""
|
|
2780
|
-
|
|
2781
|
-
|
|
2782
|
-
@send_to_subscription_administrator.setter
|
|
2783
|
-
def send_to_subscription_administrator(self, value: Optional[pulumi.Input[bool]]):
|
|
2784
|
-
pulumi.set(self, "send_to_subscription_administrator", value)
|
|
2785
|
-
|
|
2786
|
-
@property
|
|
2787
|
-
@pulumi.getter(name="sendToSubscriptionCoAdministrators")
|
|
2788
|
-
def send_to_subscription_co_administrators(self) -> Optional[pulumi.Input[bool]]:
|
|
3094
|
+
time_aggregation: pulumi.Input[Union[str, 'AggregationTypeEnum']]
|
|
2789
3095
|
"""
|
|
2790
|
-
|
|
3096
|
+
the criteria time aggregation types.
|
|
2791
3097
|
"""
|
|
2792
|
-
|
|
2793
|
-
|
|
2794
|
-
@send_to_subscription_co_administrators.setter
|
|
2795
|
-
def send_to_subscription_co_administrators(self, value: Optional[pulumi.Input[bool]]):
|
|
2796
|
-
pulumi.set(self, "send_to_subscription_co_administrators", value)
|
|
2797
|
-
|
|
2798
|
-
|
|
2799
|
-
if not MYPY:
|
|
2800
|
-
class EmailReceiverArgsDict(TypedDict):
|
|
3098
|
+
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgsDict']]]]
|
|
2801
3099
|
"""
|
|
2802
|
-
|
|
3100
|
+
List of dimension conditions.
|
|
2803
3101
|
"""
|
|
2804
|
-
|
|
3102
|
+
ignore_data_before: NotRequired[pulumi.Input[str]]
|
|
2805
3103
|
"""
|
|
2806
|
-
|
|
3104
|
+
Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
|
|
2807
3105
|
"""
|
|
2808
|
-
|
|
3106
|
+
metric_namespace: NotRequired[pulumi.Input[str]]
|
|
2809
3107
|
"""
|
|
2810
|
-
|
|
3108
|
+
Namespace of the metric.
|
|
2811
3109
|
"""
|
|
2812
|
-
|
|
3110
|
+
skip_metric_validation: NotRequired[pulumi.Input[bool]]
|
|
2813
3111
|
"""
|
|
2814
|
-
|
|
3112
|
+
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
2815
3113
|
"""
|
|
2816
3114
|
elif False:
|
|
2817
|
-
|
|
3115
|
+
DynamicMetricCriteriaArgsDict: TypeAlias = Mapping[str, Any]
|
|
2818
3116
|
|
|
2819
3117
|
@pulumi.input_type
|
|
2820
|
-
class
|
|
3118
|
+
class DynamicMetricCriteriaArgs:
|
|
2821
3119
|
def __init__(__self__, *,
|
|
2822
|
-
|
|
3120
|
+
alert_sensitivity: pulumi.Input[Union[str, 'DynamicThresholdSensitivity']],
|
|
3121
|
+
criterion_type: pulumi.Input[str],
|
|
3122
|
+
failing_periods: pulumi.Input['DynamicThresholdFailingPeriodsArgs'],
|
|
3123
|
+
metric_name: pulumi.Input[str],
|
|
2823
3124
|
name: pulumi.Input[str],
|
|
2824
|
-
|
|
2825
|
-
|
|
2826
|
-
|
|
2827
|
-
|
|
2828
|
-
|
|
2829
|
-
|
|
2830
|
-
"""
|
|
2831
|
-
|
|
3125
|
+
operator: pulumi.Input[Union[str, 'DynamicThresholdOperator']],
|
|
3126
|
+
time_aggregation: pulumi.Input[Union[str, 'AggregationTypeEnum']],
|
|
3127
|
+
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]] = None,
|
|
3128
|
+
ignore_data_before: Optional[pulumi.Input[str]] = None,
|
|
3129
|
+
metric_namespace: Optional[pulumi.Input[str]] = None,
|
|
3130
|
+
skip_metric_validation: Optional[pulumi.Input[bool]] = None):
|
|
3131
|
+
"""
|
|
3132
|
+
Criterion for dynamic threshold.
|
|
3133
|
+
:param pulumi.Input[Union[str, 'DynamicThresholdSensitivity']] alert_sensitivity: The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
|
|
3134
|
+
:param pulumi.Input[str] criterion_type: Specifies the type of threshold criteria
|
|
3135
|
+
Expected value is 'DynamicThresholdCriterion'.
|
|
3136
|
+
:param pulumi.Input['DynamicThresholdFailingPeriodsArgs'] failing_periods: The minimum number of violations required within the selected lookback time window required to raise an alert.
|
|
3137
|
+
:param pulumi.Input[str] metric_name: Name of the metric.
|
|
3138
|
+
:param pulumi.Input[str] name: Name of the criteria.
|
|
3139
|
+
:param pulumi.Input[Union[str, 'DynamicThresholdOperator']] operator: The operator used to compare the metric value against the threshold.
|
|
3140
|
+
:param pulumi.Input[Union[str, 'AggregationTypeEnum']] time_aggregation: the criteria time aggregation types.
|
|
3141
|
+
:param pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]] dimensions: List of dimension conditions.
|
|
3142
|
+
:param pulumi.Input[str] ignore_data_before: Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
|
|
3143
|
+
:param pulumi.Input[str] metric_namespace: Namespace of the metric.
|
|
3144
|
+
:param pulumi.Input[bool] skip_metric_validation: Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
3145
|
+
"""
|
|
3146
|
+
pulumi.set(__self__, "alert_sensitivity", alert_sensitivity)
|
|
3147
|
+
pulumi.set(__self__, "criterion_type", 'DynamicThresholdCriterion')
|
|
3148
|
+
pulumi.set(__self__, "failing_periods", failing_periods)
|
|
3149
|
+
pulumi.set(__self__, "metric_name", metric_name)
|
|
2832
3150
|
pulumi.set(__self__, "name", name)
|
|
2833
|
-
|
|
2834
|
-
|
|
2835
|
-
if
|
|
2836
|
-
pulumi.set(__self__, "
|
|
3151
|
+
pulumi.set(__self__, "operator", operator)
|
|
3152
|
+
pulumi.set(__self__, "time_aggregation", time_aggregation)
|
|
3153
|
+
if dimensions is not None:
|
|
3154
|
+
pulumi.set(__self__, "dimensions", dimensions)
|
|
3155
|
+
if ignore_data_before is not None:
|
|
3156
|
+
pulumi.set(__self__, "ignore_data_before", ignore_data_before)
|
|
3157
|
+
if metric_namespace is not None:
|
|
3158
|
+
pulumi.set(__self__, "metric_namespace", metric_namespace)
|
|
3159
|
+
if skip_metric_validation is not None:
|
|
3160
|
+
pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)
|
|
2837
3161
|
|
|
2838
3162
|
@property
|
|
2839
|
-
@pulumi.getter(name="
|
|
2840
|
-
def
|
|
3163
|
+
@pulumi.getter(name="alertSensitivity")
|
|
3164
|
+
def alert_sensitivity(self) -> pulumi.Input[Union[str, 'DynamicThresholdSensitivity']]:
|
|
2841
3165
|
"""
|
|
2842
|
-
The
|
|
3166
|
+
The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
|
|
2843
3167
|
"""
|
|
2844
|
-
return pulumi.get(self, "
|
|
3168
|
+
return pulumi.get(self, "alert_sensitivity")
|
|
3169
|
+
|
|
3170
|
+
@alert_sensitivity.setter
|
|
3171
|
+
def alert_sensitivity(self, value: pulumi.Input[Union[str, 'DynamicThresholdSensitivity']]):
|
|
3172
|
+
pulumi.set(self, "alert_sensitivity", value)
|
|
3173
|
+
|
|
3174
|
+
@property
|
|
3175
|
+
@pulumi.getter(name="criterionType")
|
|
3176
|
+
def criterion_type(self) -> pulumi.Input[str]:
|
|
3177
|
+
"""
|
|
3178
|
+
Specifies the type of threshold criteria
|
|
3179
|
+
Expected value is 'DynamicThresholdCriterion'.
|
|
3180
|
+
"""
|
|
3181
|
+
return pulumi.get(self, "criterion_type")
|
|
3182
|
+
|
|
3183
|
+
@criterion_type.setter
|
|
3184
|
+
def criterion_type(self, value: pulumi.Input[str]):
|
|
3185
|
+
pulumi.set(self, "criterion_type", value)
|
|
3186
|
+
|
|
3187
|
+
@property
|
|
3188
|
+
@pulumi.getter(name="failingPeriods")
|
|
3189
|
+
def failing_periods(self) -> pulumi.Input['DynamicThresholdFailingPeriodsArgs']:
|
|
3190
|
+
"""
|
|
3191
|
+
The minimum number of violations required within the selected lookback time window required to raise an alert.
|
|
3192
|
+
"""
|
|
3193
|
+
return pulumi.get(self, "failing_periods")
|
|
3194
|
+
|
|
3195
|
+
@failing_periods.setter
|
|
3196
|
+
def failing_periods(self, value: pulumi.Input['DynamicThresholdFailingPeriodsArgs']):
|
|
3197
|
+
pulumi.set(self, "failing_periods", value)
|
|
3198
|
+
|
|
3199
|
+
@property
|
|
3200
|
+
@pulumi.getter(name="metricName")
|
|
3201
|
+
def metric_name(self) -> pulumi.Input[str]:
|
|
3202
|
+
"""
|
|
3203
|
+
Name of the metric.
|
|
3204
|
+
"""
|
|
3205
|
+
return pulumi.get(self, "metric_name")
|
|
3206
|
+
|
|
3207
|
+
@metric_name.setter
|
|
3208
|
+
def metric_name(self, value: pulumi.Input[str]):
|
|
3209
|
+
pulumi.set(self, "metric_name", value)
|
|
3210
|
+
|
|
3211
|
+
@property
|
|
3212
|
+
@pulumi.getter
|
|
3213
|
+
def name(self) -> pulumi.Input[str]:
|
|
3214
|
+
"""
|
|
3215
|
+
Name of the criteria.
|
|
3216
|
+
"""
|
|
3217
|
+
return pulumi.get(self, "name")
|
|
3218
|
+
|
|
3219
|
+
@name.setter
|
|
3220
|
+
def name(self, value: pulumi.Input[str]):
|
|
3221
|
+
pulumi.set(self, "name", value)
|
|
3222
|
+
|
|
3223
|
+
@property
|
|
3224
|
+
@pulumi.getter
|
|
3225
|
+
def operator(self) -> pulumi.Input[Union[str, 'DynamicThresholdOperator']]:
|
|
3226
|
+
"""
|
|
3227
|
+
The operator used to compare the metric value against the threshold.
|
|
3228
|
+
"""
|
|
3229
|
+
return pulumi.get(self, "operator")
|
|
3230
|
+
|
|
3231
|
+
@operator.setter
|
|
3232
|
+
def operator(self, value: pulumi.Input[Union[str, 'DynamicThresholdOperator']]):
|
|
3233
|
+
pulumi.set(self, "operator", value)
|
|
3234
|
+
|
|
3235
|
+
@property
|
|
3236
|
+
@pulumi.getter(name="timeAggregation")
|
|
3237
|
+
def time_aggregation(self) -> pulumi.Input[Union[str, 'AggregationTypeEnum']]:
|
|
3238
|
+
"""
|
|
3239
|
+
the criteria time aggregation types.
|
|
3240
|
+
"""
|
|
3241
|
+
return pulumi.get(self, "time_aggregation")
|
|
3242
|
+
|
|
3243
|
+
@time_aggregation.setter
|
|
3244
|
+
def time_aggregation(self, value: pulumi.Input[Union[str, 'AggregationTypeEnum']]):
|
|
3245
|
+
pulumi.set(self, "time_aggregation", value)
|
|
3246
|
+
|
|
3247
|
+
@property
|
|
3248
|
+
@pulumi.getter
|
|
3249
|
+
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]]:
|
|
3250
|
+
"""
|
|
3251
|
+
List of dimension conditions.
|
|
3252
|
+
"""
|
|
3253
|
+
return pulumi.get(self, "dimensions")
|
|
3254
|
+
|
|
3255
|
+
@dimensions.setter
|
|
3256
|
+
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]]):
|
|
3257
|
+
pulumi.set(self, "dimensions", value)
|
|
3258
|
+
|
|
3259
|
+
@property
|
|
3260
|
+
@pulumi.getter(name="ignoreDataBefore")
|
|
3261
|
+
def ignore_data_before(self) -> Optional[pulumi.Input[str]]:
|
|
3262
|
+
"""
|
|
3263
|
+
Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
|
|
3264
|
+
"""
|
|
3265
|
+
return pulumi.get(self, "ignore_data_before")
|
|
3266
|
+
|
|
3267
|
+
@ignore_data_before.setter
|
|
3268
|
+
def ignore_data_before(self, value: Optional[pulumi.Input[str]]):
|
|
3269
|
+
pulumi.set(self, "ignore_data_before", value)
|
|
3270
|
+
|
|
3271
|
+
@property
|
|
3272
|
+
@pulumi.getter(name="metricNamespace")
|
|
3273
|
+
def metric_namespace(self) -> Optional[pulumi.Input[str]]:
|
|
3274
|
+
"""
|
|
3275
|
+
Namespace of the metric.
|
|
3276
|
+
"""
|
|
3277
|
+
return pulumi.get(self, "metric_namespace")
|
|
3278
|
+
|
|
3279
|
+
@metric_namespace.setter
|
|
3280
|
+
def metric_namespace(self, value: Optional[pulumi.Input[str]]):
|
|
3281
|
+
pulumi.set(self, "metric_namespace", value)
|
|
3282
|
+
|
|
3283
|
+
@property
|
|
3284
|
+
@pulumi.getter(name="skipMetricValidation")
|
|
3285
|
+
def skip_metric_validation(self) -> Optional[pulumi.Input[bool]]:
|
|
3286
|
+
"""
|
|
3287
|
+
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
3288
|
+
"""
|
|
3289
|
+
return pulumi.get(self, "skip_metric_validation")
|
|
3290
|
+
|
|
3291
|
+
@skip_metric_validation.setter
|
|
3292
|
+
def skip_metric_validation(self, value: Optional[pulumi.Input[bool]]):
|
|
3293
|
+
pulumi.set(self, "skip_metric_validation", value)
|
|
3294
|
+
|
|
3295
|
+
|
|
3296
|
+
if not MYPY:
|
|
3297
|
+
class DynamicThresholdFailingPeriodsArgsDict(TypedDict):
|
|
3298
|
+
"""
|
|
3299
|
+
The minimum number of violations required within the selected lookback time window required to raise an alert.
|
|
3300
|
+
"""
|
|
3301
|
+
min_failing_periods_to_alert: pulumi.Input[float]
|
|
3302
|
+
"""
|
|
3303
|
+
The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
|
|
3304
|
+
"""
|
|
3305
|
+
number_of_evaluation_periods: pulumi.Input[float]
|
|
3306
|
+
"""
|
|
3307
|
+
The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
|
|
3308
|
+
"""
|
|
3309
|
+
elif False:
|
|
3310
|
+
DynamicThresholdFailingPeriodsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3311
|
+
|
|
3312
|
+
@pulumi.input_type
|
|
3313
|
+
class DynamicThresholdFailingPeriodsArgs:
|
|
3314
|
+
def __init__(__self__, *,
|
|
3315
|
+
min_failing_periods_to_alert: pulumi.Input[float],
|
|
3316
|
+
number_of_evaluation_periods: pulumi.Input[float]):
|
|
3317
|
+
"""
|
|
3318
|
+
The minimum number of violations required within the selected lookback time window required to raise an alert.
|
|
3319
|
+
:param pulumi.Input[float] min_failing_periods_to_alert: The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
|
|
3320
|
+
:param pulumi.Input[float] number_of_evaluation_periods: The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
|
|
3321
|
+
"""
|
|
3322
|
+
pulumi.set(__self__, "min_failing_periods_to_alert", min_failing_periods_to_alert)
|
|
3323
|
+
pulumi.set(__self__, "number_of_evaluation_periods", number_of_evaluation_periods)
|
|
3324
|
+
|
|
3325
|
+
@property
|
|
3326
|
+
@pulumi.getter(name="minFailingPeriodsToAlert")
|
|
3327
|
+
def min_failing_periods_to_alert(self) -> pulumi.Input[float]:
|
|
3328
|
+
"""
|
|
3329
|
+
The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
|
|
3330
|
+
"""
|
|
3331
|
+
return pulumi.get(self, "min_failing_periods_to_alert")
|
|
3332
|
+
|
|
3333
|
+
@min_failing_periods_to_alert.setter
|
|
3334
|
+
def min_failing_periods_to_alert(self, value: pulumi.Input[float]):
|
|
3335
|
+
pulumi.set(self, "min_failing_periods_to_alert", value)
|
|
3336
|
+
|
|
3337
|
+
@property
|
|
3338
|
+
@pulumi.getter(name="numberOfEvaluationPeriods")
|
|
3339
|
+
def number_of_evaluation_periods(self) -> pulumi.Input[float]:
|
|
3340
|
+
"""
|
|
3341
|
+
The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
|
|
3342
|
+
"""
|
|
3343
|
+
return pulumi.get(self, "number_of_evaluation_periods")
|
|
3344
|
+
|
|
3345
|
+
@number_of_evaluation_periods.setter
|
|
3346
|
+
def number_of_evaluation_periods(self, value: pulumi.Input[float]):
|
|
3347
|
+
pulumi.set(self, "number_of_evaluation_periods", value)
|
|
3348
|
+
|
|
3349
|
+
|
|
3350
|
+
if not MYPY:
|
|
3351
|
+
class EmailNotificationArgsDict(TypedDict):
|
|
3352
|
+
"""
|
|
3353
|
+
Email notification of an autoscale event.
|
|
3354
|
+
"""
|
|
3355
|
+
custom_emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3356
|
+
"""
|
|
3357
|
+
the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
3358
|
+
"""
|
|
3359
|
+
send_to_subscription_administrator: NotRequired[pulumi.Input[bool]]
|
|
3360
|
+
"""
|
|
3361
|
+
a value indicating whether to send email to subscription administrator.
|
|
3362
|
+
"""
|
|
3363
|
+
send_to_subscription_co_administrators: NotRequired[pulumi.Input[bool]]
|
|
3364
|
+
"""
|
|
3365
|
+
a value indicating whether to send email to subscription co-administrators.
|
|
3366
|
+
"""
|
|
3367
|
+
elif False:
|
|
3368
|
+
EmailNotificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3369
|
+
|
|
3370
|
+
@pulumi.input_type
|
|
3371
|
+
class EmailNotificationArgs:
|
|
3372
|
+
def __init__(__self__, *,
|
|
3373
|
+
custom_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3374
|
+
send_to_subscription_administrator: Optional[pulumi.Input[bool]] = None,
|
|
3375
|
+
send_to_subscription_co_administrators: Optional[pulumi.Input[bool]] = None):
|
|
3376
|
+
"""
|
|
3377
|
+
Email notification of an autoscale event.
|
|
3378
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
3379
|
+
:param pulumi.Input[bool] send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
|
|
3380
|
+
:param pulumi.Input[bool] send_to_subscription_co_administrators: a value indicating whether to send email to subscription co-administrators.
|
|
3381
|
+
"""
|
|
3382
|
+
if custom_emails is not None:
|
|
3383
|
+
pulumi.set(__self__, "custom_emails", custom_emails)
|
|
3384
|
+
if send_to_subscription_administrator is None:
|
|
3385
|
+
send_to_subscription_administrator = False
|
|
3386
|
+
if send_to_subscription_administrator is not None:
|
|
3387
|
+
pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
|
|
3388
|
+
if send_to_subscription_co_administrators is None:
|
|
3389
|
+
send_to_subscription_co_administrators = False
|
|
3390
|
+
if send_to_subscription_co_administrators is not None:
|
|
3391
|
+
pulumi.set(__self__, "send_to_subscription_co_administrators", send_to_subscription_co_administrators)
|
|
3392
|
+
|
|
3393
|
+
@property
|
|
3394
|
+
@pulumi.getter(name="customEmails")
|
|
3395
|
+
def custom_emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3396
|
+
"""
|
|
3397
|
+
the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
3398
|
+
"""
|
|
3399
|
+
return pulumi.get(self, "custom_emails")
|
|
3400
|
+
|
|
3401
|
+
@custom_emails.setter
|
|
3402
|
+
def custom_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3403
|
+
pulumi.set(self, "custom_emails", value)
|
|
3404
|
+
|
|
3405
|
+
@property
|
|
3406
|
+
@pulumi.getter(name="sendToSubscriptionAdministrator")
|
|
3407
|
+
def send_to_subscription_administrator(self) -> Optional[pulumi.Input[bool]]:
|
|
3408
|
+
"""
|
|
3409
|
+
a value indicating whether to send email to subscription administrator.
|
|
3410
|
+
"""
|
|
3411
|
+
return pulumi.get(self, "send_to_subscription_administrator")
|
|
3412
|
+
|
|
3413
|
+
@send_to_subscription_administrator.setter
|
|
3414
|
+
def send_to_subscription_administrator(self, value: Optional[pulumi.Input[bool]]):
|
|
3415
|
+
pulumi.set(self, "send_to_subscription_administrator", value)
|
|
3416
|
+
|
|
3417
|
+
@property
|
|
3418
|
+
@pulumi.getter(name="sendToSubscriptionCoAdministrators")
|
|
3419
|
+
def send_to_subscription_co_administrators(self) -> Optional[pulumi.Input[bool]]:
|
|
3420
|
+
"""
|
|
3421
|
+
a value indicating whether to send email to subscription co-administrators.
|
|
3422
|
+
"""
|
|
3423
|
+
return pulumi.get(self, "send_to_subscription_co_administrators")
|
|
3424
|
+
|
|
3425
|
+
@send_to_subscription_co_administrators.setter
|
|
3426
|
+
def send_to_subscription_co_administrators(self, value: Optional[pulumi.Input[bool]]):
|
|
3427
|
+
pulumi.set(self, "send_to_subscription_co_administrators", value)
|
|
3428
|
+
|
|
3429
|
+
|
|
3430
|
+
if not MYPY:
|
|
3431
|
+
class EmailReceiverArgsDict(TypedDict):
|
|
3432
|
+
"""
|
|
3433
|
+
An email receiver.
|
|
3434
|
+
"""
|
|
3435
|
+
email_address: pulumi.Input[str]
|
|
3436
|
+
"""
|
|
3437
|
+
The email address of this receiver.
|
|
3438
|
+
"""
|
|
3439
|
+
name: pulumi.Input[str]
|
|
3440
|
+
"""
|
|
3441
|
+
The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
3442
|
+
"""
|
|
3443
|
+
use_common_alert_schema: NotRequired[pulumi.Input[bool]]
|
|
3444
|
+
"""
|
|
3445
|
+
Indicates whether to use common alert schema.
|
|
3446
|
+
"""
|
|
3447
|
+
elif False:
|
|
3448
|
+
EmailReceiverArgsDict: TypeAlias = Mapping[str, Any]
|
|
3449
|
+
|
|
3450
|
+
@pulumi.input_type
|
|
3451
|
+
class EmailReceiverArgs:
|
|
3452
|
+
def __init__(__self__, *,
|
|
3453
|
+
email_address: pulumi.Input[str],
|
|
3454
|
+
name: pulumi.Input[str],
|
|
3455
|
+
use_common_alert_schema: Optional[pulumi.Input[bool]] = None):
|
|
3456
|
+
"""
|
|
3457
|
+
An email receiver.
|
|
3458
|
+
:param pulumi.Input[str] email_address: The email address of this receiver.
|
|
3459
|
+
:param pulumi.Input[str] name: The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
3460
|
+
:param pulumi.Input[bool] use_common_alert_schema: Indicates whether to use common alert schema.
|
|
3461
|
+
"""
|
|
3462
|
+
pulumi.set(__self__, "email_address", email_address)
|
|
3463
|
+
pulumi.set(__self__, "name", name)
|
|
3464
|
+
if use_common_alert_schema is None:
|
|
3465
|
+
use_common_alert_schema = False
|
|
3466
|
+
if use_common_alert_schema is not None:
|
|
3467
|
+
pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
|
|
3468
|
+
|
|
3469
|
+
@property
|
|
3470
|
+
@pulumi.getter(name="emailAddress")
|
|
3471
|
+
def email_address(self) -> pulumi.Input[str]:
|
|
3472
|
+
"""
|
|
3473
|
+
The email address of this receiver.
|
|
3474
|
+
"""
|
|
3475
|
+
return pulumi.get(self, "email_address")
|
|
2845
3476
|
|
|
2846
3477
|
@email_address.setter
|
|
2847
3478
|
def email_address(self, value: pulumi.Input[str]):
|
|
@@ -4090,81 +4721,346 @@ class LogFilesDataSourceArgs:
|
|
|
4090
4721
|
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
4091
4722
|
:param pulumi.Input['LogFilesDataSourceSettingsArgs'] settings: The log files specific settings.
|
|
4092
4723
|
"""
|
|
4093
|
-
pulumi.set(__self__, "file_patterns", file_patterns)
|
|
4094
|
-
pulumi.set(__self__, "format", format)
|
|
4095
|
-
pulumi.set(__self__, "streams", streams)
|
|
4096
|
-
if name is not None:
|
|
4097
|
-
pulumi.set(__self__, "name", name)
|
|
4098
|
-
if settings is not None:
|
|
4099
|
-
pulumi.set(__self__, "settings", settings)
|
|
4724
|
+
pulumi.set(__self__, "file_patterns", file_patterns)
|
|
4725
|
+
pulumi.set(__self__, "format", format)
|
|
4726
|
+
pulumi.set(__self__, "streams", streams)
|
|
4727
|
+
if name is not None:
|
|
4728
|
+
pulumi.set(__self__, "name", name)
|
|
4729
|
+
if settings is not None:
|
|
4730
|
+
pulumi.set(__self__, "settings", settings)
|
|
4731
|
+
|
|
4732
|
+
@property
|
|
4733
|
+
@pulumi.getter(name="filePatterns")
|
|
4734
|
+
def file_patterns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
4735
|
+
"""
|
|
4736
|
+
File Patterns where the log files are located
|
|
4737
|
+
"""
|
|
4738
|
+
return pulumi.get(self, "file_patterns")
|
|
4739
|
+
|
|
4740
|
+
@file_patterns.setter
|
|
4741
|
+
def file_patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
4742
|
+
pulumi.set(self, "file_patterns", value)
|
|
4743
|
+
|
|
4744
|
+
@property
|
|
4745
|
+
@pulumi.getter
|
|
4746
|
+
def format(self) -> pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']]:
|
|
4747
|
+
"""
|
|
4748
|
+
The data format of the log files
|
|
4749
|
+
"""
|
|
4750
|
+
return pulumi.get(self, "format")
|
|
4751
|
+
|
|
4752
|
+
@format.setter
|
|
4753
|
+
def format(self, value: pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']]):
|
|
4754
|
+
pulumi.set(self, "format", value)
|
|
4755
|
+
|
|
4756
|
+
@property
|
|
4757
|
+
@pulumi.getter
|
|
4758
|
+
def streams(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
4759
|
+
"""
|
|
4760
|
+
List of streams that this data source will be sent to.
|
|
4761
|
+
A stream indicates what schema will be used for this data source
|
|
4762
|
+
"""
|
|
4763
|
+
return pulumi.get(self, "streams")
|
|
4764
|
+
|
|
4765
|
+
@streams.setter
|
|
4766
|
+
def streams(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
4767
|
+
pulumi.set(self, "streams", value)
|
|
4768
|
+
|
|
4769
|
+
@property
|
|
4770
|
+
@pulumi.getter
|
|
4771
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
4772
|
+
"""
|
|
4773
|
+
A friendly name for the data source.
|
|
4774
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
4775
|
+
"""
|
|
4776
|
+
return pulumi.get(self, "name")
|
|
4777
|
+
|
|
4778
|
+
@name.setter
|
|
4779
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
4780
|
+
pulumi.set(self, "name", value)
|
|
4781
|
+
|
|
4782
|
+
@property
|
|
4783
|
+
@pulumi.getter
|
|
4784
|
+
def settings(self) -> Optional[pulumi.Input['LogFilesDataSourceSettingsArgs']]:
|
|
4785
|
+
"""
|
|
4786
|
+
The log files specific settings.
|
|
4787
|
+
"""
|
|
4788
|
+
return pulumi.get(self, "settings")
|
|
4789
|
+
|
|
4790
|
+
@settings.setter
|
|
4791
|
+
def settings(self, value: Optional[pulumi.Input['LogFilesDataSourceSettingsArgs']]):
|
|
4792
|
+
pulumi.set(self, "settings", value)
|
|
4793
|
+
|
|
4794
|
+
|
|
4795
|
+
if not MYPY:
|
|
4796
|
+
class LogSettingsArgsDict(TypedDict):
|
|
4797
|
+
"""
|
|
4798
|
+
Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
|
|
4799
|
+
"""
|
|
4800
|
+
enabled: pulumi.Input[bool]
|
|
4801
|
+
"""
|
|
4802
|
+
a value indicating whether this log is enabled.
|
|
4803
|
+
"""
|
|
4804
|
+
category: NotRequired[pulumi.Input[str]]
|
|
4805
|
+
"""
|
|
4806
|
+
Name of a Diagnostic Log category for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4807
|
+
"""
|
|
4808
|
+
category_group: NotRequired[pulumi.Input[str]]
|
|
4809
|
+
"""
|
|
4810
|
+
Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4811
|
+
"""
|
|
4812
|
+
retention_policy: NotRequired[pulumi.Input['RetentionPolicyArgsDict']]
|
|
4813
|
+
"""
|
|
4814
|
+
the retention policy for this log.
|
|
4815
|
+
"""
|
|
4816
|
+
elif False:
|
|
4817
|
+
LogSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4818
|
+
|
|
4819
|
+
@pulumi.input_type
|
|
4820
|
+
class LogSettingsArgs:
|
|
4821
|
+
def __init__(__self__, *,
|
|
4822
|
+
enabled: pulumi.Input[bool],
|
|
4823
|
+
category: Optional[pulumi.Input[str]] = None,
|
|
4824
|
+
category_group: Optional[pulumi.Input[str]] = None,
|
|
4825
|
+
retention_policy: Optional[pulumi.Input['RetentionPolicyArgs']] = None):
|
|
4826
|
+
"""
|
|
4827
|
+
Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
|
|
4828
|
+
:param pulumi.Input[bool] enabled: a value indicating whether this log is enabled.
|
|
4829
|
+
:param pulumi.Input[str] category: Name of a Diagnostic Log category for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4830
|
+
:param pulumi.Input[str] category_group: Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4831
|
+
:param pulumi.Input['RetentionPolicyArgs'] retention_policy: the retention policy for this log.
|
|
4832
|
+
"""
|
|
4833
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
4834
|
+
if category is not None:
|
|
4835
|
+
pulumi.set(__self__, "category", category)
|
|
4836
|
+
if category_group is not None:
|
|
4837
|
+
pulumi.set(__self__, "category_group", category_group)
|
|
4838
|
+
if retention_policy is not None:
|
|
4839
|
+
pulumi.set(__self__, "retention_policy", retention_policy)
|
|
4840
|
+
|
|
4841
|
+
@property
|
|
4842
|
+
@pulumi.getter
|
|
4843
|
+
def enabled(self) -> pulumi.Input[bool]:
|
|
4844
|
+
"""
|
|
4845
|
+
a value indicating whether this log is enabled.
|
|
4846
|
+
"""
|
|
4847
|
+
return pulumi.get(self, "enabled")
|
|
4848
|
+
|
|
4849
|
+
@enabled.setter
|
|
4850
|
+
def enabled(self, value: pulumi.Input[bool]):
|
|
4851
|
+
pulumi.set(self, "enabled", value)
|
|
4852
|
+
|
|
4853
|
+
@property
|
|
4854
|
+
@pulumi.getter
|
|
4855
|
+
def category(self) -> Optional[pulumi.Input[str]]:
|
|
4856
|
+
"""
|
|
4857
|
+
Name of a Diagnostic Log category for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4858
|
+
"""
|
|
4859
|
+
return pulumi.get(self, "category")
|
|
4860
|
+
|
|
4861
|
+
@category.setter
|
|
4862
|
+
def category(self, value: Optional[pulumi.Input[str]]):
|
|
4863
|
+
pulumi.set(self, "category", value)
|
|
4864
|
+
|
|
4865
|
+
@property
|
|
4866
|
+
@pulumi.getter(name="categoryGroup")
|
|
4867
|
+
def category_group(self) -> Optional[pulumi.Input[str]]:
|
|
4868
|
+
"""
|
|
4869
|
+
Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
|
|
4870
|
+
"""
|
|
4871
|
+
return pulumi.get(self, "category_group")
|
|
4872
|
+
|
|
4873
|
+
@category_group.setter
|
|
4874
|
+
def category_group(self, value: Optional[pulumi.Input[str]]):
|
|
4875
|
+
pulumi.set(self, "category_group", value)
|
|
4876
|
+
|
|
4877
|
+
@property
|
|
4878
|
+
@pulumi.getter(name="retentionPolicy")
|
|
4879
|
+
def retention_policy(self) -> Optional[pulumi.Input['RetentionPolicyArgs']]:
|
|
4880
|
+
"""
|
|
4881
|
+
the retention policy for this log.
|
|
4882
|
+
"""
|
|
4883
|
+
return pulumi.get(self, "retention_policy")
|
|
4884
|
+
|
|
4885
|
+
@retention_policy.setter
|
|
4886
|
+
def retention_policy(self, value: Optional[pulumi.Input['RetentionPolicyArgs']]):
|
|
4887
|
+
pulumi.set(self, "retention_policy", value)
|
|
4888
|
+
|
|
4889
|
+
|
|
4890
|
+
if not MYPY:
|
|
4891
|
+
class LogicAppReceiverArgsDict(TypedDict):
|
|
4892
|
+
"""
|
|
4893
|
+
A logic app receiver.
|
|
4894
|
+
"""
|
|
4895
|
+
callback_url: pulumi.Input[str]
|
|
4896
|
+
"""
|
|
4897
|
+
The callback url where http request sent to.
|
|
4898
|
+
"""
|
|
4899
|
+
name: pulumi.Input[str]
|
|
4900
|
+
"""
|
|
4901
|
+
The name of the logic app receiver. Names must be unique across all receivers within an action group.
|
|
4902
|
+
"""
|
|
4903
|
+
resource_id: pulumi.Input[str]
|
|
4904
|
+
"""
|
|
4905
|
+
The azure resource id of the logic app receiver.
|
|
4906
|
+
"""
|
|
4907
|
+
managed_identity: NotRequired[pulumi.Input[str]]
|
|
4908
|
+
"""
|
|
4909
|
+
The principal id of the managed identity. The value can be "None", "SystemAssigned"
|
|
4910
|
+
"""
|
|
4911
|
+
use_common_alert_schema: NotRequired[pulumi.Input[bool]]
|
|
4912
|
+
"""
|
|
4913
|
+
Indicates whether to use common alert schema.
|
|
4914
|
+
"""
|
|
4915
|
+
elif False:
|
|
4916
|
+
LogicAppReceiverArgsDict: TypeAlias = Mapping[str, Any]
|
|
4917
|
+
|
|
4918
|
+
@pulumi.input_type
|
|
4919
|
+
class LogicAppReceiverArgs:
|
|
4920
|
+
def __init__(__self__, *,
|
|
4921
|
+
callback_url: pulumi.Input[str],
|
|
4922
|
+
name: pulumi.Input[str],
|
|
4923
|
+
resource_id: pulumi.Input[str],
|
|
4924
|
+
managed_identity: Optional[pulumi.Input[str]] = None,
|
|
4925
|
+
use_common_alert_schema: Optional[pulumi.Input[bool]] = None):
|
|
4926
|
+
"""
|
|
4927
|
+
A logic app receiver.
|
|
4928
|
+
:param pulumi.Input[str] callback_url: The callback url where http request sent to.
|
|
4929
|
+
:param pulumi.Input[str] name: The name of the logic app receiver. Names must be unique across all receivers within an action group.
|
|
4930
|
+
:param pulumi.Input[str] resource_id: The azure resource id of the logic app receiver.
|
|
4931
|
+
:param pulumi.Input[str] managed_identity: The principal id of the managed identity. The value can be "None", "SystemAssigned"
|
|
4932
|
+
:param pulumi.Input[bool] use_common_alert_schema: Indicates whether to use common alert schema.
|
|
4933
|
+
"""
|
|
4934
|
+
pulumi.set(__self__, "callback_url", callback_url)
|
|
4935
|
+
pulumi.set(__self__, "name", name)
|
|
4936
|
+
pulumi.set(__self__, "resource_id", resource_id)
|
|
4937
|
+
if managed_identity is not None:
|
|
4938
|
+
pulumi.set(__self__, "managed_identity", managed_identity)
|
|
4939
|
+
if use_common_alert_schema is None:
|
|
4940
|
+
use_common_alert_schema = False
|
|
4941
|
+
if use_common_alert_schema is not None:
|
|
4942
|
+
pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
|
|
4943
|
+
|
|
4944
|
+
@property
|
|
4945
|
+
@pulumi.getter(name="callbackUrl")
|
|
4946
|
+
def callback_url(self) -> pulumi.Input[str]:
|
|
4947
|
+
"""
|
|
4948
|
+
The callback url where http request sent to.
|
|
4949
|
+
"""
|
|
4950
|
+
return pulumi.get(self, "callback_url")
|
|
4951
|
+
|
|
4952
|
+
@callback_url.setter
|
|
4953
|
+
def callback_url(self, value: pulumi.Input[str]):
|
|
4954
|
+
pulumi.set(self, "callback_url", value)
|
|
4955
|
+
|
|
4956
|
+
@property
|
|
4957
|
+
@pulumi.getter
|
|
4958
|
+
def name(self) -> pulumi.Input[str]:
|
|
4959
|
+
"""
|
|
4960
|
+
The name of the logic app receiver. Names must be unique across all receivers within an action group.
|
|
4961
|
+
"""
|
|
4962
|
+
return pulumi.get(self, "name")
|
|
4963
|
+
|
|
4964
|
+
@name.setter
|
|
4965
|
+
def name(self, value: pulumi.Input[str]):
|
|
4966
|
+
pulumi.set(self, "name", value)
|
|
4100
4967
|
|
|
4101
4968
|
@property
|
|
4102
|
-
@pulumi.getter(name="
|
|
4103
|
-
def
|
|
4969
|
+
@pulumi.getter(name="resourceId")
|
|
4970
|
+
def resource_id(self) -> pulumi.Input[str]:
|
|
4104
4971
|
"""
|
|
4105
|
-
|
|
4972
|
+
The azure resource id of the logic app receiver.
|
|
4106
4973
|
"""
|
|
4107
|
-
return pulumi.get(self, "
|
|
4974
|
+
return pulumi.get(self, "resource_id")
|
|
4108
4975
|
|
|
4109
|
-
@
|
|
4110
|
-
def
|
|
4111
|
-
pulumi.set(self, "
|
|
4976
|
+
@resource_id.setter
|
|
4977
|
+
def resource_id(self, value: pulumi.Input[str]):
|
|
4978
|
+
pulumi.set(self, "resource_id", value)
|
|
4112
4979
|
|
|
4113
4980
|
@property
|
|
4114
|
-
@pulumi.getter
|
|
4115
|
-
def
|
|
4981
|
+
@pulumi.getter(name="managedIdentity")
|
|
4982
|
+
def managed_identity(self) -> Optional[pulumi.Input[str]]:
|
|
4116
4983
|
"""
|
|
4117
|
-
The
|
|
4984
|
+
The principal id of the managed identity. The value can be "None", "SystemAssigned"
|
|
4118
4985
|
"""
|
|
4119
|
-
return pulumi.get(self, "
|
|
4986
|
+
return pulumi.get(self, "managed_identity")
|
|
4120
4987
|
|
|
4121
|
-
@
|
|
4122
|
-
def
|
|
4123
|
-
pulumi.set(self, "
|
|
4988
|
+
@managed_identity.setter
|
|
4989
|
+
def managed_identity(self, value: Optional[pulumi.Input[str]]):
|
|
4990
|
+
pulumi.set(self, "managed_identity", value)
|
|
4124
4991
|
|
|
4125
4992
|
@property
|
|
4126
|
-
@pulumi.getter
|
|
4127
|
-
def
|
|
4993
|
+
@pulumi.getter(name="useCommonAlertSchema")
|
|
4994
|
+
def use_common_alert_schema(self) -> Optional[pulumi.Input[bool]]:
|
|
4128
4995
|
"""
|
|
4129
|
-
|
|
4130
|
-
A stream indicates what schema will be used for this data source
|
|
4996
|
+
Indicates whether to use common alert schema.
|
|
4131
4997
|
"""
|
|
4132
|
-
return pulumi.get(self, "
|
|
4998
|
+
return pulumi.get(self, "use_common_alert_schema")
|
|
4999
|
+
|
|
5000
|
+
@use_common_alert_schema.setter
|
|
5001
|
+
def use_common_alert_schema(self, value: Optional[pulumi.Input[bool]]):
|
|
5002
|
+
pulumi.set(self, "use_common_alert_schema", value)
|
|
4133
5003
|
|
|
4134
|
-
|
|
4135
|
-
|
|
4136
|
-
|
|
5004
|
+
|
|
5005
|
+
if not MYPY:
|
|
5006
|
+
class ManagedServiceIdentityArgsDict(TypedDict):
|
|
5007
|
+
"""
|
|
5008
|
+
Managed service identity (system assigned and/or user assigned identities)
|
|
5009
|
+
"""
|
|
5010
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]
|
|
5011
|
+
"""
|
|
5012
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
5013
|
+
"""
|
|
5014
|
+
user_assigned_identities: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5015
|
+
"""
|
|
5016
|
+
The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
|
|
5017
|
+
"""
|
|
5018
|
+
elif False:
|
|
5019
|
+
ManagedServiceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
5020
|
+
|
|
5021
|
+
@pulumi.input_type
|
|
5022
|
+
class ManagedServiceIdentityArgs:
|
|
5023
|
+
def __init__(__self__, *,
|
|
5024
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']],
|
|
5025
|
+
user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
5026
|
+
"""
|
|
5027
|
+
Managed service identity (system assigned and/or user assigned identities)
|
|
5028
|
+
:param pulumi.Input[Union[str, 'ManagedServiceIdentityType']] type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
5029
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
|
|
5030
|
+
"""
|
|
5031
|
+
pulumi.set(__self__, "type", type)
|
|
5032
|
+
if user_assigned_identities is not None:
|
|
5033
|
+
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
|
|
4137
5034
|
|
|
4138
5035
|
@property
|
|
4139
5036
|
@pulumi.getter
|
|
4140
|
-
def
|
|
5037
|
+
def type(self) -> pulumi.Input[Union[str, 'ManagedServiceIdentityType']]:
|
|
4141
5038
|
"""
|
|
4142
|
-
|
|
4143
|
-
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5039
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
4144
5040
|
"""
|
|
4145
|
-
return pulumi.get(self, "
|
|
5041
|
+
return pulumi.get(self, "type")
|
|
4146
5042
|
|
|
4147
|
-
@
|
|
4148
|
-
def
|
|
4149
|
-
pulumi.set(self, "
|
|
5043
|
+
@type.setter
|
|
5044
|
+
def type(self, value: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]):
|
|
5045
|
+
pulumi.set(self, "type", value)
|
|
4150
5046
|
|
|
4151
5047
|
@property
|
|
4152
|
-
@pulumi.getter
|
|
4153
|
-
def
|
|
5048
|
+
@pulumi.getter(name="userAssignedIdentities")
|
|
5049
|
+
def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
4154
5050
|
"""
|
|
4155
|
-
The
|
|
5051
|
+
The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
|
|
4156
5052
|
"""
|
|
4157
|
-
return pulumi.get(self, "
|
|
5053
|
+
return pulumi.get(self, "user_assigned_identities")
|
|
4158
5054
|
|
|
4159
|
-
@
|
|
4160
|
-
def
|
|
4161
|
-
pulumi.set(self, "
|
|
5055
|
+
@user_assigned_identities.setter
|
|
5056
|
+
def user_assigned_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
5057
|
+
pulumi.set(self, "user_assigned_identities", value)
|
|
4162
5058
|
|
|
4163
5059
|
|
|
4164
5060
|
if not MYPY:
|
|
4165
|
-
class
|
|
5061
|
+
class ManagementGroupLogSettingsArgsDict(TypedDict):
|
|
4166
5062
|
"""
|
|
4167
|
-
Part of
|
|
5063
|
+
Part of Management Group diagnostic setting. Specifies the settings for a particular log.
|
|
4168
5064
|
"""
|
|
4169
5065
|
enabled: pulumi.Input[bool]
|
|
4170
5066
|
"""
|
|
@@ -4172,40 +5068,32 @@ if not MYPY:
|
|
|
4172
5068
|
"""
|
|
4173
5069
|
category: NotRequired[pulumi.Input[str]]
|
|
4174
5070
|
"""
|
|
4175
|
-
Name of a Diagnostic Log category for a resource type this setting is applied to.
|
|
5071
|
+
Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
|
|
4176
5072
|
"""
|
|
4177
5073
|
category_group: NotRequired[pulumi.Input[str]]
|
|
4178
5074
|
"""
|
|
4179
|
-
Name of a Diagnostic Log category group for a resource type this setting is applied to.
|
|
4180
|
-
"""
|
|
4181
|
-
retention_policy: NotRequired[pulumi.Input['RetentionPolicyArgsDict']]
|
|
4182
|
-
"""
|
|
4183
|
-
the retention policy for this log.
|
|
5075
|
+
Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
|
|
4184
5076
|
"""
|
|
4185
5077
|
elif False:
|
|
4186
|
-
|
|
5078
|
+
ManagementGroupLogSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4187
5079
|
|
|
4188
5080
|
@pulumi.input_type
|
|
4189
|
-
class
|
|
5081
|
+
class ManagementGroupLogSettingsArgs:
|
|
4190
5082
|
def __init__(__self__, *,
|
|
4191
5083
|
enabled: pulumi.Input[bool],
|
|
4192
5084
|
category: Optional[pulumi.Input[str]] = None,
|
|
4193
|
-
category_group: Optional[pulumi.Input[str]] = None
|
|
4194
|
-
retention_policy: Optional[pulumi.Input['RetentionPolicyArgs']] = None):
|
|
5085
|
+
category_group: Optional[pulumi.Input[str]] = None):
|
|
4195
5086
|
"""
|
|
4196
|
-
Part of
|
|
5087
|
+
Part of Management Group diagnostic setting. Specifies the settings for a particular log.
|
|
4197
5088
|
:param pulumi.Input[bool] enabled: a value indicating whether this log is enabled.
|
|
4198
|
-
:param pulumi.Input[str] category: Name of a Diagnostic Log category for a resource type this setting is applied to.
|
|
4199
|
-
:param pulumi.Input[str] category_group: Name of a Diagnostic Log category group for a resource type this setting is applied to.
|
|
4200
|
-
:param pulumi.Input['RetentionPolicyArgs'] retention_policy: the retention policy for this log.
|
|
5089
|
+
:param pulumi.Input[str] category: Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
|
|
5090
|
+
:param pulumi.Input[str] category_group: Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
|
|
4201
5091
|
"""
|
|
4202
5092
|
pulumi.set(__self__, "enabled", enabled)
|
|
4203
5093
|
if category is not None:
|
|
4204
5094
|
pulumi.set(__self__, "category", category)
|
|
4205
5095
|
if category_group is not None:
|
|
4206
5096
|
pulumi.set(__self__, "category_group", category_group)
|
|
4207
|
-
if retention_policy is not None:
|
|
4208
|
-
pulumi.set(__self__, "retention_policy", retention_policy)
|
|
4209
5097
|
|
|
4210
5098
|
@property
|
|
4211
5099
|
@pulumi.getter
|
|
@@ -4223,7 +5111,7 @@ class LogSettingsArgs:
|
|
|
4223
5111
|
@pulumi.getter
|
|
4224
5112
|
def category(self) -> Optional[pulumi.Input[str]]:
|
|
4225
5113
|
"""
|
|
4226
|
-
Name of a Diagnostic Log category for a resource type this setting is applied to.
|
|
5114
|
+
Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
|
|
4227
5115
|
"""
|
|
4228
5116
|
return pulumi.get(self, "category")
|
|
4229
5117
|
|
|
@@ -4235,7 +5123,7 @@ class LogSettingsArgs:
|
|
|
4235
5123
|
@pulumi.getter(name="categoryGroup")
|
|
4236
5124
|
def category_group(self) -> Optional[pulumi.Input[str]]:
|
|
4237
5125
|
"""
|
|
4238
|
-
Name of a Diagnostic Log category group for a resource type this setting is applied to.
|
|
5126
|
+
Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
|
|
4239
5127
|
"""
|
|
4240
5128
|
return pulumi.get(self, "category_group")
|
|
4241
5129
|
|
|
@@ -4243,90 +5131,292 @@ class LogSettingsArgs:
|
|
|
4243
5131
|
def category_group(self, value: Optional[pulumi.Input[str]]):
|
|
4244
5132
|
pulumi.set(self, "category_group", value)
|
|
4245
5133
|
|
|
5134
|
+
|
|
5135
|
+
if not MYPY:
|
|
5136
|
+
class MetricAlertActionArgsDict(TypedDict):
|
|
5137
|
+
"""
|
|
5138
|
+
An alert action.
|
|
5139
|
+
"""
|
|
5140
|
+
action_group_id: NotRequired[pulumi.Input[str]]
|
|
5141
|
+
"""
|
|
5142
|
+
the id of the action group to use.
|
|
5143
|
+
"""
|
|
5144
|
+
web_hook_properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
5145
|
+
"""
|
|
5146
|
+
This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
|
|
5147
|
+
"""
|
|
5148
|
+
elif False:
|
|
5149
|
+
MetricAlertActionArgsDict: TypeAlias = Mapping[str, Any]
|
|
5150
|
+
|
|
5151
|
+
@pulumi.input_type
|
|
5152
|
+
class MetricAlertActionArgs:
|
|
5153
|
+
def __init__(__self__, *,
|
|
5154
|
+
action_group_id: Optional[pulumi.Input[str]] = None,
|
|
5155
|
+
web_hook_properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
5156
|
+
"""
|
|
5157
|
+
An alert action.
|
|
5158
|
+
:param pulumi.Input[str] action_group_id: the id of the action group to use.
|
|
5159
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] web_hook_properties: This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
|
|
5160
|
+
"""
|
|
5161
|
+
if action_group_id is not None:
|
|
5162
|
+
pulumi.set(__self__, "action_group_id", action_group_id)
|
|
5163
|
+
if web_hook_properties is not None:
|
|
5164
|
+
pulumi.set(__self__, "web_hook_properties", web_hook_properties)
|
|
5165
|
+
|
|
4246
5166
|
@property
|
|
4247
|
-
@pulumi.getter(name="
|
|
4248
|
-
def
|
|
5167
|
+
@pulumi.getter(name="actionGroupId")
|
|
5168
|
+
def action_group_id(self) -> Optional[pulumi.Input[str]]:
|
|
4249
5169
|
"""
|
|
4250
|
-
the
|
|
5170
|
+
the id of the action group to use.
|
|
4251
5171
|
"""
|
|
4252
|
-
return pulumi.get(self, "
|
|
5172
|
+
return pulumi.get(self, "action_group_id")
|
|
4253
5173
|
|
|
4254
|
-
@
|
|
4255
|
-
def
|
|
4256
|
-
pulumi.set(self, "
|
|
5174
|
+
@action_group_id.setter
|
|
5175
|
+
def action_group_id(self, value: Optional[pulumi.Input[str]]):
|
|
5176
|
+
pulumi.set(self, "action_group_id", value)
|
|
5177
|
+
|
|
5178
|
+
@property
|
|
5179
|
+
@pulumi.getter(name="webHookProperties")
|
|
5180
|
+
def web_hook_properties(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
5181
|
+
"""
|
|
5182
|
+
This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
|
|
5183
|
+
"""
|
|
5184
|
+
return pulumi.get(self, "web_hook_properties")
|
|
5185
|
+
|
|
5186
|
+
@web_hook_properties.setter
|
|
5187
|
+
def web_hook_properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
5188
|
+
pulumi.set(self, "web_hook_properties", value)
|
|
4257
5189
|
|
|
4258
5190
|
|
|
4259
5191
|
if not MYPY:
|
|
4260
|
-
class
|
|
5192
|
+
class MetricAlertMultipleResourceMultipleMetricCriteriaArgsDict(TypedDict):
|
|
4261
5193
|
"""
|
|
4262
|
-
|
|
5194
|
+
Specifies the metric alert criteria for multiple resource that has multiple metric criteria.
|
|
4263
5195
|
"""
|
|
4264
|
-
|
|
5196
|
+
odata_type: pulumi.Input[str]
|
|
5197
|
+
"""
|
|
5198
|
+
specifies the type of the alert criteria.
|
|
5199
|
+
Expected value is 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria'.
|
|
5200
|
+
"""
|
|
5201
|
+
all_of: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union['DynamicMetricCriteriaArgsDict', 'MetricCriteriaArgsDict']]]]]
|
|
5202
|
+
"""
|
|
5203
|
+
the list of multiple metric criteria for this 'all of' operation.
|
|
5204
|
+
"""
|
|
5205
|
+
elif False:
|
|
5206
|
+
MetricAlertMultipleResourceMultipleMetricCriteriaArgsDict: TypeAlias = Mapping[str, Any]
|
|
5207
|
+
|
|
5208
|
+
@pulumi.input_type
|
|
5209
|
+
class MetricAlertMultipleResourceMultipleMetricCriteriaArgs:
|
|
5210
|
+
def __init__(__self__, *,
|
|
5211
|
+
odata_type: pulumi.Input[str],
|
|
5212
|
+
all_of: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicMetricCriteriaArgs', 'MetricCriteriaArgs']]]]] = None):
|
|
5213
|
+
"""
|
|
5214
|
+
Specifies the metric alert criteria for multiple resource that has multiple metric criteria.
|
|
5215
|
+
:param pulumi.Input[str] odata_type: specifies the type of the alert criteria.
|
|
5216
|
+
Expected value is 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria'.
|
|
5217
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DynamicMetricCriteriaArgs', 'MetricCriteriaArgs']]]] all_of: the list of multiple metric criteria for this 'all of' operation.
|
|
5218
|
+
"""
|
|
5219
|
+
pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria')
|
|
5220
|
+
if all_of is not None:
|
|
5221
|
+
pulumi.set(__self__, "all_of", all_of)
|
|
5222
|
+
|
|
5223
|
+
@property
|
|
5224
|
+
@pulumi.getter(name="odataType")
|
|
5225
|
+
def odata_type(self) -> pulumi.Input[str]:
|
|
5226
|
+
"""
|
|
5227
|
+
specifies the type of the alert criteria.
|
|
5228
|
+
Expected value is 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria'.
|
|
5229
|
+
"""
|
|
5230
|
+
return pulumi.get(self, "odata_type")
|
|
5231
|
+
|
|
5232
|
+
@odata_type.setter
|
|
5233
|
+
def odata_type(self, value: pulumi.Input[str]):
|
|
5234
|
+
pulumi.set(self, "odata_type", value)
|
|
5235
|
+
|
|
5236
|
+
@property
|
|
5237
|
+
@pulumi.getter(name="allOf")
|
|
5238
|
+
def all_of(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicMetricCriteriaArgs', 'MetricCriteriaArgs']]]]]:
|
|
5239
|
+
"""
|
|
5240
|
+
the list of multiple metric criteria for this 'all of' operation.
|
|
5241
|
+
"""
|
|
5242
|
+
return pulumi.get(self, "all_of")
|
|
5243
|
+
|
|
5244
|
+
@all_of.setter
|
|
5245
|
+
def all_of(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicMetricCriteriaArgs', 'MetricCriteriaArgs']]]]]):
|
|
5246
|
+
pulumi.set(self, "all_of", value)
|
|
5247
|
+
|
|
5248
|
+
|
|
5249
|
+
if not MYPY:
|
|
5250
|
+
class MetricAlertSingleResourceMultipleMetricCriteriaArgsDict(TypedDict):
|
|
5251
|
+
"""
|
|
5252
|
+
Specifies the metric alert criteria for a single resource that has multiple metric criteria.
|
|
5253
|
+
"""
|
|
5254
|
+
odata_type: pulumi.Input[str]
|
|
5255
|
+
"""
|
|
5256
|
+
specifies the type of the alert criteria.
|
|
5257
|
+
Expected value is 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria'.
|
|
5258
|
+
"""
|
|
5259
|
+
all_of: NotRequired[pulumi.Input[Sequence[pulumi.Input['MetricCriteriaArgsDict']]]]
|
|
5260
|
+
"""
|
|
5261
|
+
The list of metric criteria for this 'all of' operation.
|
|
5262
|
+
"""
|
|
5263
|
+
elif False:
|
|
5264
|
+
MetricAlertSingleResourceMultipleMetricCriteriaArgsDict: TypeAlias = Mapping[str, Any]
|
|
5265
|
+
|
|
5266
|
+
@pulumi.input_type
|
|
5267
|
+
class MetricAlertSingleResourceMultipleMetricCriteriaArgs:
|
|
5268
|
+
def __init__(__self__, *,
|
|
5269
|
+
odata_type: pulumi.Input[str],
|
|
5270
|
+
all_of: Optional[pulumi.Input[Sequence[pulumi.Input['MetricCriteriaArgs']]]] = None):
|
|
5271
|
+
"""
|
|
5272
|
+
Specifies the metric alert criteria for a single resource that has multiple metric criteria.
|
|
5273
|
+
:param pulumi.Input[str] odata_type: specifies the type of the alert criteria.
|
|
5274
|
+
Expected value is 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria'.
|
|
5275
|
+
:param pulumi.Input[Sequence[pulumi.Input['MetricCriteriaArgs']]] all_of: The list of metric criteria for this 'all of' operation.
|
|
5276
|
+
"""
|
|
5277
|
+
pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria')
|
|
5278
|
+
if all_of is not None:
|
|
5279
|
+
pulumi.set(__self__, "all_of", all_of)
|
|
5280
|
+
|
|
5281
|
+
@property
|
|
5282
|
+
@pulumi.getter(name="odataType")
|
|
5283
|
+
def odata_type(self) -> pulumi.Input[str]:
|
|
5284
|
+
"""
|
|
5285
|
+
specifies the type of the alert criteria.
|
|
5286
|
+
Expected value is 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria'.
|
|
5287
|
+
"""
|
|
5288
|
+
return pulumi.get(self, "odata_type")
|
|
5289
|
+
|
|
5290
|
+
@odata_type.setter
|
|
5291
|
+
def odata_type(self, value: pulumi.Input[str]):
|
|
5292
|
+
pulumi.set(self, "odata_type", value)
|
|
5293
|
+
|
|
5294
|
+
@property
|
|
5295
|
+
@pulumi.getter(name="allOf")
|
|
5296
|
+
def all_of(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MetricCriteriaArgs']]]]:
|
|
5297
|
+
"""
|
|
5298
|
+
The list of metric criteria for this 'all of' operation.
|
|
5299
|
+
"""
|
|
5300
|
+
return pulumi.get(self, "all_of")
|
|
5301
|
+
|
|
5302
|
+
@all_of.setter
|
|
5303
|
+
def all_of(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MetricCriteriaArgs']]]]):
|
|
5304
|
+
pulumi.set(self, "all_of", value)
|
|
5305
|
+
|
|
5306
|
+
|
|
5307
|
+
if not MYPY:
|
|
5308
|
+
class MetricCriteriaArgsDict(TypedDict):
|
|
5309
|
+
"""
|
|
5310
|
+
Criterion to filter metrics.
|
|
5311
|
+
"""
|
|
5312
|
+
criterion_type: pulumi.Input[str]
|
|
5313
|
+
"""
|
|
5314
|
+
Specifies the type of threshold criteria
|
|
5315
|
+
Expected value is 'StaticThresholdCriterion'.
|
|
5316
|
+
"""
|
|
5317
|
+
metric_name: pulumi.Input[str]
|
|
5318
|
+
"""
|
|
5319
|
+
Name of the metric.
|
|
5320
|
+
"""
|
|
5321
|
+
name: pulumi.Input[str]
|
|
5322
|
+
"""
|
|
5323
|
+
Name of the criteria.
|
|
5324
|
+
"""
|
|
5325
|
+
operator: pulumi.Input[Union[str, 'Operator']]
|
|
5326
|
+
"""
|
|
5327
|
+
the criteria operator.
|
|
5328
|
+
"""
|
|
5329
|
+
threshold: pulumi.Input[float]
|
|
4265
5330
|
"""
|
|
4266
|
-
|
|
5331
|
+
the criteria threshold value that activates the alert.
|
|
4267
5332
|
"""
|
|
4268
|
-
|
|
5333
|
+
time_aggregation: pulumi.Input[Union[str, 'AggregationTypeEnum']]
|
|
4269
5334
|
"""
|
|
4270
|
-
|
|
5335
|
+
the criteria time aggregation types.
|
|
4271
5336
|
"""
|
|
4272
|
-
|
|
5337
|
+
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgsDict']]]]
|
|
4273
5338
|
"""
|
|
4274
|
-
|
|
5339
|
+
List of dimension conditions.
|
|
4275
5340
|
"""
|
|
4276
|
-
|
|
5341
|
+
metric_namespace: NotRequired[pulumi.Input[str]]
|
|
4277
5342
|
"""
|
|
4278
|
-
|
|
5343
|
+
Namespace of the metric.
|
|
4279
5344
|
"""
|
|
4280
|
-
|
|
5345
|
+
skip_metric_validation: NotRequired[pulumi.Input[bool]]
|
|
4281
5346
|
"""
|
|
4282
|
-
|
|
5347
|
+
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
4283
5348
|
"""
|
|
4284
5349
|
elif False:
|
|
4285
|
-
|
|
5350
|
+
MetricCriteriaArgsDict: TypeAlias = Mapping[str, Any]
|
|
4286
5351
|
|
|
4287
5352
|
@pulumi.input_type
|
|
4288
|
-
class
|
|
5353
|
+
class MetricCriteriaArgs:
|
|
4289
5354
|
def __init__(__self__, *,
|
|
4290
|
-
|
|
5355
|
+
criterion_type: pulumi.Input[str],
|
|
5356
|
+
metric_name: pulumi.Input[str],
|
|
4291
5357
|
name: pulumi.Input[str],
|
|
4292
|
-
|
|
4293
|
-
|
|
4294
|
-
|
|
5358
|
+
operator: pulumi.Input[Union[str, 'Operator']],
|
|
5359
|
+
threshold: pulumi.Input[float],
|
|
5360
|
+
time_aggregation: pulumi.Input[Union[str, 'AggregationTypeEnum']],
|
|
5361
|
+
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]] = None,
|
|
5362
|
+
metric_namespace: Optional[pulumi.Input[str]] = None,
|
|
5363
|
+
skip_metric_validation: Optional[pulumi.Input[bool]] = None):
|
|
5364
|
+
"""
|
|
5365
|
+
Criterion to filter metrics.
|
|
5366
|
+
:param pulumi.Input[str] criterion_type: Specifies the type of threshold criteria
|
|
5367
|
+
Expected value is 'StaticThresholdCriterion'.
|
|
5368
|
+
:param pulumi.Input[str] metric_name: Name of the metric.
|
|
5369
|
+
:param pulumi.Input[str] name: Name of the criteria.
|
|
5370
|
+
:param pulumi.Input[Union[str, 'Operator']] operator: the criteria operator.
|
|
5371
|
+
:param pulumi.Input[float] threshold: the criteria threshold value that activates the alert.
|
|
5372
|
+
:param pulumi.Input[Union[str, 'AggregationTypeEnum']] time_aggregation: the criteria time aggregation types.
|
|
5373
|
+
:param pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]] dimensions: List of dimension conditions.
|
|
5374
|
+
:param pulumi.Input[str] metric_namespace: Namespace of the metric.
|
|
5375
|
+
:param pulumi.Input[bool] skip_metric_validation: Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
5376
|
+
"""
|
|
5377
|
+
pulumi.set(__self__, "criterion_type", 'StaticThresholdCriterion')
|
|
5378
|
+
pulumi.set(__self__, "metric_name", metric_name)
|
|
5379
|
+
pulumi.set(__self__, "name", name)
|
|
5380
|
+
pulumi.set(__self__, "operator", operator)
|
|
5381
|
+
pulumi.set(__self__, "threshold", threshold)
|
|
5382
|
+
pulumi.set(__self__, "time_aggregation", time_aggregation)
|
|
5383
|
+
if dimensions is not None:
|
|
5384
|
+
pulumi.set(__self__, "dimensions", dimensions)
|
|
5385
|
+
if metric_namespace is not None:
|
|
5386
|
+
pulumi.set(__self__, "metric_namespace", metric_namespace)
|
|
5387
|
+
if skip_metric_validation is not None:
|
|
5388
|
+
pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)
|
|
5389
|
+
|
|
5390
|
+
@property
|
|
5391
|
+
@pulumi.getter(name="criterionType")
|
|
5392
|
+
def criterion_type(self) -> pulumi.Input[str]:
|
|
4295
5393
|
"""
|
|
4296
|
-
|
|
4297
|
-
|
|
4298
|
-
:param pulumi.Input[str] name: The name of the logic app receiver. Names must be unique across all receivers within an action group.
|
|
4299
|
-
:param pulumi.Input[str] resource_id: The azure resource id of the logic app receiver.
|
|
4300
|
-
:param pulumi.Input[str] managed_identity: The principal id of the managed identity. The value can be "None", "SystemAssigned"
|
|
4301
|
-
:param pulumi.Input[bool] use_common_alert_schema: Indicates whether to use common alert schema.
|
|
5394
|
+
Specifies the type of threshold criteria
|
|
5395
|
+
Expected value is 'StaticThresholdCriterion'.
|
|
4302
5396
|
"""
|
|
4303
|
-
pulumi.
|
|
4304
|
-
|
|
4305
|
-
|
|
4306
|
-
|
|
4307
|
-
|
|
4308
|
-
if use_common_alert_schema is None:
|
|
4309
|
-
use_common_alert_schema = False
|
|
4310
|
-
if use_common_alert_schema is not None:
|
|
4311
|
-
pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
|
|
5397
|
+
return pulumi.get(self, "criterion_type")
|
|
5398
|
+
|
|
5399
|
+
@criterion_type.setter
|
|
5400
|
+
def criterion_type(self, value: pulumi.Input[str]):
|
|
5401
|
+
pulumi.set(self, "criterion_type", value)
|
|
4312
5402
|
|
|
4313
5403
|
@property
|
|
4314
|
-
@pulumi.getter(name="
|
|
4315
|
-
def
|
|
5404
|
+
@pulumi.getter(name="metricName")
|
|
5405
|
+
def metric_name(self) -> pulumi.Input[str]:
|
|
4316
5406
|
"""
|
|
4317
|
-
|
|
5407
|
+
Name of the metric.
|
|
4318
5408
|
"""
|
|
4319
|
-
return pulumi.get(self, "
|
|
5409
|
+
return pulumi.get(self, "metric_name")
|
|
4320
5410
|
|
|
4321
|
-
@
|
|
4322
|
-
def
|
|
4323
|
-
pulumi.set(self, "
|
|
5411
|
+
@metric_name.setter
|
|
5412
|
+
def metric_name(self, value: pulumi.Input[str]):
|
|
5413
|
+
pulumi.set(self, "metric_name", value)
|
|
4324
5414
|
|
|
4325
5415
|
@property
|
|
4326
5416
|
@pulumi.getter
|
|
4327
5417
|
def name(self) -> pulumi.Input[str]:
|
|
4328
5418
|
"""
|
|
4329
|
-
|
|
5419
|
+
Name of the criteria.
|
|
4330
5420
|
"""
|
|
4331
5421
|
return pulumi.get(self, "name")
|
|
4332
5422
|
|
|
@@ -4335,170 +5425,149 @@ class LogicAppReceiverArgs:
|
|
|
4335
5425
|
pulumi.set(self, "name", value)
|
|
4336
5426
|
|
|
4337
5427
|
@property
|
|
4338
|
-
@pulumi.getter
|
|
4339
|
-
def
|
|
5428
|
+
@pulumi.getter
|
|
5429
|
+
def operator(self) -> pulumi.Input[Union[str, 'Operator']]:
|
|
4340
5430
|
"""
|
|
4341
|
-
|
|
5431
|
+
the criteria operator.
|
|
4342
5432
|
"""
|
|
4343
|
-
return pulumi.get(self, "
|
|
5433
|
+
return pulumi.get(self, "operator")
|
|
4344
5434
|
|
|
4345
|
-
@
|
|
4346
|
-
def
|
|
4347
|
-
pulumi.set(self, "
|
|
5435
|
+
@operator.setter
|
|
5436
|
+
def operator(self, value: pulumi.Input[Union[str, 'Operator']]):
|
|
5437
|
+
pulumi.set(self, "operator", value)
|
|
4348
5438
|
|
|
4349
5439
|
@property
|
|
4350
|
-
@pulumi.getter
|
|
4351
|
-
def
|
|
5440
|
+
@pulumi.getter
|
|
5441
|
+
def threshold(self) -> pulumi.Input[float]:
|
|
4352
5442
|
"""
|
|
4353
|
-
|
|
5443
|
+
the criteria threshold value that activates the alert.
|
|
4354
5444
|
"""
|
|
4355
|
-
return pulumi.get(self, "
|
|
5445
|
+
return pulumi.get(self, "threshold")
|
|
4356
5446
|
|
|
4357
|
-
@
|
|
4358
|
-
def
|
|
4359
|
-
pulumi.set(self, "
|
|
5447
|
+
@threshold.setter
|
|
5448
|
+
def threshold(self, value: pulumi.Input[float]):
|
|
5449
|
+
pulumi.set(self, "threshold", value)
|
|
4360
5450
|
|
|
4361
5451
|
@property
|
|
4362
|
-
@pulumi.getter(name="
|
|
4363
|
-
def
|
|
5452
|
+
@pulumi.getter(name="timeAggregation")
|
|
5453
|
+
def time_aggregation(self) -> pulumi.Input[Union[str, 'AggregationTypeEnum']]:
|
|
4364
5454
|
"""
|
|
4365
|
-
|
|
5455
|
+
the criteria time aggregation types.
|
|
4366
5456
|
"""
|
|
4367
|
-
return pulumi.get(self, "
|
|
4368
|
-
|
|
4369
|
-
@use_common_alert_schema.setter
|
|
4370
|
-
def use_common_alert_schema(self, value: Optional[pulumi.Input[bool]]):
|
|
4371
|
-
pulumi.set(self, "use_common_alert_schema", value)
|
|
5457
|
+
return pulumi.get(self, "time_aggregation")
|
|
4372
5458
|
|
|
5459
|
+
@time_aggregation.setter
|
|
5460
|
+
def time_aggregation(self, value: pulumi.Input[Union[str, 'AggregationTypeEnum']]):
|
|
5461
|
+
pulumi.set(self, "time_aggregation", value)
|
|
4373
5462
|
|
|
4374
|
-
|
|
4375
|
-
|
|
4376
|
-
|
|
4377
|
-
Managed service identity (system assigned and/or user assigned identities)
|
|
4378
|
-
"""
|
|
4379
|
-
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]
|
|
4380
|
-
"""
|
|
4381
|
-
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
4382
|
-
"""
|
|
4383
|
-
user_assigned_identities: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5463
|
+
@property
|
|
5464
|
+
@pulumi.getter
|
|
5465
|
+
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]]:
|
|
4384
5466
|
"""
|
|
4385
|
-
|
|
5467
|
+
List of dimension conditions.
|
|
4386
5468
|
"""
|
|
4387
|
-
|
|
4388
|
-
ManagedServiceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
5469
|
+
return pulumi.get(self, "dimensions")
|
|
4389
5470
|
|
|
4390
|
-
@
|
|
4391
|
-
|
|
4392
|
-
|
|
4393
|
-
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']],
|
|
4394
|
-
user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
4395
|
-
"""
|
|
4396
|
-
Managed service identity (system assigned and/or user assigned identities)
|
|
4397
|
-
:param pulumi.Input[Union[str, 'ManagedServiceIdentityType']] type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
4398
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
|
|
4399
|
-
"""
|
|
4400
|
-
pulumi.set(__self__, "type", type)
|
|
4401
|
-
if user_assigned_identities is not None:
|
|
4402
|
-
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
|
|
5471
|
+
@dimensions.setter
|
|
5472
|
+
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MetricDimensionArgs']]]]):
|
|
5473
|
+
pulumi.set(self, "dimensions", value)
|
|
4403
5474
|
|
|
4404
5475
|
@property
|
|
4405
|
-
@pulumi.getter
|
|
4406
|
-
def
|
|
5476
|
+
@pulumi.getter(name="metricNamespace")
|
|
5477
|
+
def metric_namespace(self) -> Optional[pulumi.Input[str]]:
|
|
4407
5478
|
"""
|
|
4408
|
-
|
|
5479
|
+
Namespace of the metric.
|
|
4409
5480
|
"""
|
|
4410
|
-
return pulumi.get(self, "
|
|
5481
|
+
return pulumi.get(self, "metric_namespace")
|
|
4411
5482
|
|
|
4412
|
-
@
|
|
4413
|
-
def
|
|
4414
|
-
pulumi.set(self, "
|
|
5483
|
+
@metric_namespace.setter
|
|
5484
|
+
def metric_namespace(self, value: Optional[pulumi.Input[str]]):
|
|
5485
|
+
pulumi.set(self, "metric_namespace", value)
|
|
4415
5486
|
|
|
4416
5487
|
@property
|
|
4417
|
-
@pulumi.getter(name="
|
|
4418
|
-
def
|
|
5488
|
+
@pulumi.getter(name="skipMetricValidation")
|
|
5489
|
+
def skip_metric_validation(self) -> Optional[pulumi.Input[bool]]:
|
|
4419
5490
|
"""
|
|
4420
|
-
|
|
5491
|
+
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
|
|
4421
5492
|
"""
|
|
4422
|
-
return pulumi.get(self, "
|
|
5493
|
+
return pulumi.get(self, "skip_metric_validation")
|
|
4423
5494
|
|
|
4424
|
-
@
|
|
4425
|
-
def
|
|
4426
|
-
pulumi.set(self, "
|
|
5495
|
+
@skip_metric_validation.setter
|
|
5496
|
+
def skip_metric_validation(self, value: Optional[pulumi.Input[bool]]):
|
|
5497
|
+
pulumi.set(self, "skip_metric_validation", value)
|
|
4427
5498
|
|
|
4428
5499
|
|
|
4429
5500
|
if not MYPY:
|
|
4430
|
-
class
|
|
5501
|
+
class MetricDimensionArgsDict(TypedDict):
|
|
4431
5502
|
"""
|
|
4432
|
-
|
|
5503
|
+
Specifies a metric dimension.
|
|
4433
5504
|
"""
|
|
4434
|
-
|
|
5505
|
+
name: pulumi.Input[str]
|
|
4435
5506
|
"""
|
|
4436
|
-
|
|
5507
|
+
Name of the dimension.
|
|
4437
5508
|
"""
|
|
4438
|
-
|
|
5509
|
+
operator: pulumi.Input[str]
|
|
4439
5510
|
"""
|
|
4440
|
-
|
|
5511
|
+
the dimension operator. Only 'Include' and 'Exclude' are supported
|
|
4441
5512
|
"""
|
|
4442
|
-
|
|
5513
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
4443
5514
|
"""
|
|
4444
|
-
|
|
5515
|
+
list of dimension values.
|
|
4445
5516
|
"""
|
|
4446
5517
|
elif False:
|
|
4447
|
-
|
|
5518
|
+
MetricDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
4448
5519
|
|
|
4449
5520
|
@pulumi.input_type
|
|
4450
|
-
class
|
|
5521
|
+
class MetricDimensionArgs:
|
|
4451
5522
|
def __init__(__self__, *,
|
|
4452
|
-
|
|
4453
|
-
|
|
4454
|
-
|
|
5523
|
+
name: pulumi.Input[str],
|
|
5524
|
+
operator: pulumi.Input[str],
|
|
5525
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
4455
5526
|
"""
|
|
4456
|
-
|
|
4457
|
-
:param pulumi.Input[
|
|
4458
|
-
:param pulumi.Input[str]
|
|
4459
|
-
:param pulumi.Input[str]
|
|
5527
|
+
Specifies a metric dimension.
|
|
5528
|
+
:param pulumi.Input[str] name: Name of the dimension.
|
|
5529
|
+
:param pulumi.Input[str] operator: the dimension operator. Only 'Include' and 'Exclude' are supported
|
|
5530
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: list of dimension values.
|
|
4460
5531
|
"""
|
|
4461
|
-
pulumi.set(__self__, "
|
|
4462
|
-
|
|
4463
|
-
|
|
4464
|
-
if category_group is not None:
|
|
4465
|
-
pulumi.set(__self__, "category_group", category_group)
|
|
5532
|
+
pulumi.set(__self__, "name", name)
|
|
5533
|
+
pulumi.set(__self__, "operator", operator)
|
|
5534
|
+
pulumi.set(__self__, "values", values)
|
|
4466
5535
|
|
|
4467
5536
|
@property
|
|
4468
5537
|
@pulumi.getter
|
|
4469
|
-
def
|
|
5538
|
+
def name(self) -> pulumi.Input[str]:
|
|
4470
5539
|
"""
|
|
4471
|
-
|
|
5540
|
+
Name of the dimension.
|
|
4472
5541
|
"""
|
|
4473
|
-
return pulumi.get(self, "
|
|
5542
|
+
return pulumi.get(self, "name")
|
|
4474
5543
|
|
|
4475
|
-
@
|
|
4476
|
-
def
|
|
4477
|
-
pulumi.set(self, "
|
|
5544
|
+
@name.setter
|
|
5545
|
+
def name(self, value: pulumi.Input[str]):
|
|
5546
|
+
pulumi.set(self, "name", value)
|
|
4478
5547
|
|
|
4479
5548
|
@property
|
|
4480
5549
|
@pulumi.getter
|
|
4481
|
-
def
|
|
5550
|
+
def operator(self) -> pulumi.Input[str]:
|
|
4482
5551
|
"""
|
|
4483
|
-
|
|
5552
|
+
the dimension operator. Only 'Include' and 'Exclude' are supported
|
|
4484
5553
|
"""
|
|
4485
|
-
return pulumi.get(self, "
|
|
5554
|
+
return pulumi.get(self, "operator")
|
|
4486
5555
|
|
|
4487
|
-
@
|
|
4488
|
-
def
|
|
4489
|
-
pulumi.set(self, "
|
|
5556
|
+
@operator.setter
|
|
5557
|
+
def operator(self, value: pulumi.Input[str]):
|
|
5558
|
+
pulumi.set(self, "operator", value)
|
|
4490
5559
|
|
|
4491
5560
|
@property
|
|
4492
|
-
@pulumi.getter
|
|
4493
|
-
def
|
|
5561
|
+
@pulumi.getter
|
|
5562
|
+
def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
4494
5563
|
"""
|
|
4495
|
-
|
|
5564
|
+
list of dimension values.
|
|
4496
5565
|
"""
|
|
4497
|
-
return pulumi.get(self, "
|
|
5566
|
+
return pulumi.get(self, "values")
|
|
4498
5567
|
|
|
4499
|
-
@
|
|
4500
|
-
def
|
|
4501
|
-
pulumi.set(self, "
|
|
5568
|
+
@values.setter
|
|
5569
|
+
def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
5570
|
+
pulumi.set(self, "values", value)
|
|
4502
5571
|
|
|
4503
5572
|
|
|
4504
5573
|
if not MYPY:
|
|
@@ -7847,6 +8916,101 @@ class WebhookReceiverArgs:
|
|
|
7847
8916
|
pulumi.set(self, "use_common_alert_schema", value)
|
|
7848
8917
|
|
|
7849
8918
|
|
|
8919
|
+
if not MYPY:
|
|
8920
|
+
class WebtestLocationAvailabilityCriteriaArgsDict(TypedDict):
|
|
8921
|
+
"""
|
|
8922
|
+
Specifies the metric alert rule criteria for a web test resource.
|
|
8923
|
+
"""
|
|
8924
|
+
component_id: pulumi.Input[str]
|
|
8925
|
+
"""
|
|
8926
|
+
The Application Insights resource Id.
|
|
8927
|
+
"""
|
|
8928
|
+
failed_location_count: pulumi.Input[float]
|
|
8929
|
+
"""
|
|
8930
|
+
The number of failed locations.
|
|
8931
|
+
"""
|
|
8932
|
+
odata_type: pulumi.Input[str]
|
|
8933
|
+
"""
|
|
8934
|
+
specifies the type of the alert criteria.
|
|
8935
|
+
Expected value is 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria'.
|
|
8936
|
+
"""
|
|
8937
|
+
web_test_id: pulumi.Input[str]
|
|
8938
|
+
"""
|
|
8939
|
+
The Application Insights web test Id.
|
|
8940
|
+
"""
|
|
8941
|
+
elif False:
|
|
8942
|
+
WebtestLocationAvailabilityCriteriaArgsDict: TypeAlias = Mapping[str, Any]
|
|
8943
|
+
|
|
8944
|
+
@pulumi.input_type
|
|
8945
|
+
class WebtestLocationAvailabilityCriteriaArgs:
|
|
8946
|
+
def __init__(__self__, *,
|
|
8947
|
+
component_id: pulumi.Input[str],
|
|
8948
|
+
failed_location_count: pulumi.Input[float],
|
|
8949
|
+
odata_type: pulumi.Input[str],
|
|
8950
|
+
web_test_id: pulumi.Input[str]):
|
|
8951
|
+
"""
|
|
8952
|
+
Specifies the metric alert rule criteria for a web test resource.
|
|
8953
|
+
:param pulumi.Input[str] component_id: The Application Insights resource Id.
|
|
8954
|
+
:param pulumi.Input[float] failed_location_count: The number of failed locations.
|
|
8955
|
+
:param pulumi.Input[str] odata_type: specifies the type of the alert criteria.
|
|
8956
|
+
Expected value is 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria'.
|
|
8957
|
+
:param pulumi.Input[str] web_test_id: The Application Insights web test Id.
|
|
8958
|
+
"""
|
|
8959
|
+
pulumi.set(__self__, "component_id", component_id)
|
|
8960
|
+
pulumi.set(__self__, "failed_location_count", failed_location_count)
|
|
8961
|
+
pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria')
|
|
8962
|
+
pulumi.set(__self__, "web_test_id", web_test_id)
|
|
8963
|
+
|
|
8964
|
+
@property
|
|
8965
|
+
@pulumi.getter(name="componentId")
|
|
8966
|
+
def component_id(self) -> pulumi.Input[str]:
|
|
8967
|
+
"""
|
|
8968
|
+
The Application Insights resource Id.
|
|
8969
|
+
"""
|
|
8970
|
+
return pulumi.get(self, "component_id")
|
|
8971
|
+
|
|
8972
|
+
@component_id.setter
|
|
8973
|
+
def component_id(self, value: pulumi.Input[str]):
|
|
8974
|
+
pulumi.set(self, "component_id", value)
|
|
8975
|
+
|
|
8976
|
+
@property
|
|
8977
|
+
@pulumi.getter(name="failedLocationCount")
|
|
8978
|
+
def failed_location_count(self) -> pulumi.Input[float]:
|
|
8979
|
+
"""
|
|
8980
|
+
The number of failed locations.
|
|
8981
|
+
"""
|
|
8982
|
+
return pulumi.get(self, "failed_location_count")
|
|
8983
|
+
|
|
8984
|
+
@failed_location_count.setter
|
|
8985
|
+
def failed_location_count(self, value: pulumi.Input[float]):
|
|
8986
|
+
pulumi.set(self, "failed_location_count", value)
|
|
8987
|
+
|
|
8988
|
+
@property
|
|
8989
|
+
@pulumi.getter(name="odataType")
|
|
8990
|
+
def odata_type(self) -> pulumi.Input[str]:
|
|
8991
|
+
"""
|
|
8992
|
+
specifies the type of the alert criteria.
|
|
8993
|
+
Expected value is 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria'.
|
|
8994
|
+
"""
|
|
8995
|
+
return pulumi.get(self, "odata_type")
|
|
8996
|
+
|
|
8997
|
+
@odata_type.setter
|
|
8998
|
+
def odata_type(self, value: pulumi.Input[str]):
|
|
8999
|
+
pulumi.set(self, "odata_type", value)
|
|
9000
|
+
|
|
9001
|
+
@property
|
|
9002
|
+
@pulumi.getter(name="webTestId")
|
|
9003
|
+
def web_test_id(self) -> pulumi.Input[str]:
|
|
9004
|
+
"""
|
|
9005
|
+
The Application Insights web test Id.
|
|
9006
|
+
"""
|
|
9007
|
+
return pulumi.get(self, "web_test_id")
|
|
9008
|
+
|
|
9009
|
+
@web_test_id.setter
|
|
9010
|
+
def web_test_id(self, value: pulumi.Input[str]):
|
|
9011
|
+
pulumi.set(self, "web_test_id", value)
|
|
9012
|
+
|
|
9013
|
+
|
|
7850
9014
|
if not MYPY:
|
|
7851
9015
|
class WindowsEventLogDataSourceArgsDict(TypedDict):
|
|
7852
9016
|
"""
|