pulumi-azure-native 3.1.0a1744014979__py3-none-any.whl → 3.1.0a1744041749__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 +3 -0
- pulumi_azure_native/monitor/__init__.py +6 -0
- pulumi_azure_native/monitor/_enums.py +150 -0
- pulumi_azure_native/monitor/_inputs.py +2496 -270
- pulumi_azure_native/monitor/action_group.py +2 -2
- pulumi_azure_native/monitor/data_collection_endpoint.py +468 -0
- pulumi_azure_native/monitor/data_collection_rule.py +519 -0
- pulumi_azure_native/monitor/data_collection_rule_association.py +300 -0
- pulumi_azure_native/monitor/get_action_group.py +2 -2
- pulumi_azure_native/monitor/get_data_collection_endpoint.py +357 -0
- pulumi_azure_native/monitor/get_data_collection_rule.py +344 -0
- pulumi_azure_native/monitor/get_data_collection_rule_association.py +231 -0
- pulumi_azure_native/monitor/outputs.py +2653 -75
- pulumi_azure_native/pulumi-plugin.json +1 -1
- {pulumi_azure_native-3.1.0a1744014979.dist-info → pulumi_azure_native-3.1.0a1744041749.dist-info}/METADATA +1 -1
- {pulumi_azure_native-3.1.0a1744014979.dist-info → pulumi_azure_native-3.1.0a1744041749.dist-info}/RECORD +18 -12
- {pulumi_azure_native-3.1.0a1744014979.dist-info → pulumi_azure_native-3.1.0a1744041749.dist-info}/WHEEL +0 -0
- {pulumi_azure_native-3.1.0a1744014979.dist-info → pulumi_azure_native-3.1.0a1744041749.dist-info}/top_level.txt +0 -0
|
@@ -44,24 +44,52 @@ __all__ = [
|
|
|
44
44
|
'BatchProcessorArgsDict',
|
|
45
45
|
'CacheConfigurationArgs',
|
|
46
46
|
'CacheConfigurationArgsDict',
|
|
47
|
+
'ColumnDefinitionArgs',
|
|
48
|
+
'ColumnDefinitionArgsDict',
|
|
47
49
|
'ConcurrencyConfigurationArgs',
|
|
48
50
|
'ConcurrencyConfigurationArgsDict',
|
|
49
51
|
'ConditionFailingPeriodsArgs',
|
|
50
52
|
'ConditionFailingPeriodsArgsDict',
|
|
51
53
|
'ConditionArgs',
|
|
52
54
|
'ConditionArgsDict',
|
|
55
|
+
'DataCollectionEndpointNetworkAclsArgs',
|
|
56
|
+
'DataCollectionEndpointNetworkAclsArgsDict',
|
|
57
|
+
'DataCollectionEndpointResourceIdentityArgs',
|
|
58
|
+
'DataCollectionEndpointResourceIdentityArgsDict',
|
|
59
|
+
'DataCollectionRuleDataSourcesArgs',
|
|
60
|
+
'DataCollectionRuleDataSourcesArgsDict',
|
|
61
|
+
'DataCollectionRuleDestinationsArgs',
|
|
62
|
+
'DataCollectionRuleDestinationsArgsDict',
|
|
63
|
+
'DataCollectionRuleResourceIdentityArgs',
|
|
64
|
+
'DataCollectionRuleResourceIdentityArgsDict',
|
|
65
|
+
'DataFlowArgs',
|
|
66
|
+
'DataFlowArgsDict',
|
|
67
|
+
'DataImportSourcesEventHubArgs',
|
|
68
|
+
'DataImportSourcesEventHubArgsDict',
|
|
69
|
+
'DataSourcesSpecDataImportsArgs',
|
|
70
|
+
'DataSourcesSpecDataImportsArgsDict',
|
|
71
|
+
'DestinationsSpecAzureMonitorMetricsArgs',
|
|
72
|
+
'DestinationsSpecAzureMonitorMetricsArgsDict',
|
|
53
73
|
'DimensionArgs',
|
|
54
74
|
'DimensionArgsDict',
|
|
55
75
|
'EmailNotificationArgs',
|
|
56
76
|
'EmailNotificationArgsDict',
|
|
57
77
|
'EmailReceiverArgs',
|
|
58
78
|
'EmailReceiverArgsDict',
|
|
79
|
+
'EventHubDestinationArgs',
|
|
80
|
+
'EventHubDestinationArgsDict',
|
|
81
|
+
'EventHubDirectDestinationArgs',
|
|
82
|
+
'EventHubDirectDestinationArgsDict',
|
|
59
83
|
'EventHubReceiverArgs',
|
|
60
84
|
'EventHubReceiverArgsDict',
|
|
61
85
|
'ExporterArgs',
|
|
62
86
|
'ExporterArgsDict',
|
|
87
|
+
'ExtensionDataSourceArgs',
|
|
88
|
+
'ExtensionDataSourceArgsDict',
|
|
63
89
|
'IdentityArgs',
|
|
64
90
|
'IdentityArgsDict',
|
|
91
|
+
'IisLogsDataSourceArgs',
|
|
92
|
+
'IisLogsDataSourceArgsDict',
|
|
65
93
|
'IncidentReceiverArgs',
|
|
66
94
|
'IncidentReceiverArgsDict',
|
|
67
95
|
'IncidentServiceConnectionArgs',
|
|
@@ -74,6 +102,14 @@ __all__ = [
|
|
|
74
102
|
'JsonMapperDestinationFieldArgsDict',
|
|
75
103
|
'JsonMapperSourceFieldArgs',
|
|
76
104
|
'JsonMapperSourceFieldArgsDict',
|
|
105
|
+
'LogAnalyticsDestinationArgs',
|
|
106
|
+
'LogAnalyticsDestinationArgsDict',
|
|
107
|
+
'LogFileSettingsTextArgs',
|
|
108
|
+
'LogFileSettingsTextArgsDict',
|
|
109
|
+
'LogFilesDataSourceSettingsArgs',
|
|
110
|
+
'LogFilesDataSourceSettingsArgsDict',
|
|
111
|
+
'LogFilesDataSourceArgs',
|
|
112
|
+
'LogFilesDataSourceArgsDict',
|
|
77
113
|
'LogSettingsArgs',
|
|
78
114
|
'LogSettingsArgsDict',
|
|
79
115
|
'LogicAppReceiverArgs',
|
|
@@ -86,24 +122,32 @@ __all__ = [
|
|
|
86
122
|
'MetricSettingsArgsDict',
|
|
87
123
|
'MetricTriggerArgs',
|
|
88
124
|
'MetricTriggerArgsDict',
|
|
125
|
+
'MonitoringAccountDestinationArgs',
|
|
126
|
+
'MonitoringAccountDestinationArgsDict',
|
|
89
127
|
'NetworkingConfigurationArgs',
|
|
90
128
|
'NetworkingConfigurationArgsDict',
|
|
91
129
|
'NetworkingRouteArgs',
|
|
92
130
|
'NetworkingRouteArgsDict',
|
|
93
131
|
'OtlpReceiverArgs',
|
|
94
132
|
'OtlpReceiverArgsDict',
|
|
133
|
+
'PerfCounterDataSourceArgs',
|
|
134
|
+
'PerfCounterDataSourceArgsDict',
|
|
95
135
|
'PersistenceConfigurationsArgs',
|
|
96
136
|
'PersistenceConfigurationsArgsDict',
|
|
97
137
|
'PipelineGroupPropertiesArgs',
|
|
98
138
|
'PipelineGroupPropertiesArgsDict',
|
|
99
139
|
'PipelineArgs',
|
|
100
140
|
'PipelineArgsDict',
|
|
141
|
+
'PlatformTelemetryDataSourceArgs',
|
|
142
|
+
'PlatformTelemetryDataSourceArgsDict',
|
|
101
143
|
'PredictiveAutoscalePolicyArgs',
|
|
102
144
|
'PredictiveAutoscalePolicyArgsDict',
|
|
103
145
|
'PrivateLinkServiceConnectionStateArgs',
|
|
104
146
|
'PrivateLinkServiceConnectionStateArgsDict',
|
|
105
147
|
'ProcessorArgs',
|
|
106
148
|
'ProcessorArgsDict',
|
|
149
|
+
'PrometheusForwarderDataSourceArgs',
|
|
150
|
+
'PrometheusForwarderDataSourceArgsDict',
|
|
107
151
|
'ReceiverArgs',
|
|
108
152
|
'ReceiverArgsDict',
|
|
109
153
|
'RecordMapArgs',
|
|
@@ -136,8 +180,16 @@ __all__ = [
|
|
|
136
180
|
'ServiceArgsDict',
|
|
137
181
|
'SmsReceiverArgs',
|
|
138
182
|
'SmsReceiverArgsDict',
|
|
183
|
+
'StorageBlobDestinationArgs',
|
|
184
|
+
'StorageBlobDestinationArgsDict',
|
|
185
|
+
'StorageTableDestinationArgs',
|
|
186
|
+
'StorageTableDestinationArgsDict',
|
|
187
|
+
'StreamDeclarationArgs',
|
|
188
|
+
'StreamDeclarationArgsDict',
|
|
139
189
|
'SubscriptionLogSettingsArgs',
|
|
140
190
|
'SubscriptionLogSettingsArgsDict',
|
|
191
|
+
'SyslogDataSourceArgs',
|
|
192
|
+
'SyslogDataSourceArgsDict',
|
|
141
193
|
'SyslogReceiverArgs',
|
|
142
194
|
'SyslogReceiverArgsDict',
|
|
143
195
|
'TcpExporterArgs',
|
|
@@ -152,6 +204,10 @@ __all__ = [
|
|
|
152
204
|
'WebhookNotificationArgsDict',
|
|
153
205
|
'WebhookReceiverArgs',
|
|
154
206
|
'WebhookReceiverArgsDict',
|
|
207
|
+
'WindowsEventLogDataSourceArgs',
|
|
208
|
+
'WindowsEventLogDataSourceArgsDict',
|
|
209
|
+
'WindowsFirewallLogsDataSourceArgs',
|
|
210
|
+
'WindowsFirewallLogsDataSourceArgsDict',
|
|
155
211
|
]
|
|
156
212
|
|
|
157
213
|
MYPY = False
|
|
@@ -1345,6 +1401,62 @@ class CacheConfigurationArgs:
|
|
|
1345
1401
|
pulumi.set(self, "retention_period", value)
|
|
1346
1402
|
|
|
1347
1403
|
|
|
1404
|
+
if not MYPY:
|
|
1405
|
+
class ColumnDefinitionArgsDict(TypedDict):
|
|
1406
|
+
"""
|
|
1407
|
+
Definition of custom data column.
|
|
1408
|
+
"""
|
|
1409
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1410
|
+
"""
|
|
1411
|
+
The name of the column.
|
|
1412
|
+
"""
|
|
1413
|
+
type: NotRequired[pulumi.Input[Union[str, 'KnownColumnDefinitionType']]]
|
|
1414
|
+
"""
|
|
1415
|
+
The type of the column data.
|
|
1416
|
+
"""
|
|
1417
|
+
elif False:
|
|
1418
|
+
ColumnDefinitionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1419
|
+
|
|
1420
|
+
@pulumi.input_type
|
|
1421
|
+
class ColumnDefinitionArgs:
|
|
1422
|
+
def __init__(__self__, *,
|
|
1423
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1424
|
+
type: Optional[pulumi.Input[Union[str, 'KnownColumnDefinitionType']]] = None):
|
|
1425
|
+
"""
|
|
1426
|
+
Definition of custom data column.
|
|
1427
|
+
:param pulumi.Input[str] name: The name of the column.
|
|
1428
|
+
:param pulumi.Input[Union[str, 'KnownColumnDefinitionType']] type: The type of the column data.
|
|
1429
|
+
"""
|
|
1430
|
+
if name is not None:
|
|
1431
|
+
pulumi.set(__self__, "name", name)
|
|
1432
|
+
if type is not None:
|
|
1433
|
+
pulumi.set(__self__, "type", type)
|
|
1434
|
+
|
|
1435
|
+
@property
|
|
1436
|
+
@pulumi.getter
|
|
1437
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1438
|
+
"""
|
|
1439
|
+
The name of the column.
|
|
1440
|
+
"""
|
|
1441
|
+
return pulumi.get(self, "name")
|
|
1442
|
+
|
|
1443
|
+
@name.setter
|
|
1444
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1445
|
+
pulumi.set(self, "name", value)
|
|
1446
|
+
|
|
1447
|
+
@property
|
|
1448
|
+
@pulumi.getter
|
|
1449
|
+
def type(self) -> Optional[pulumi.Input[Union[str, 'KnownColumnDefinitionType']]]:
|
|
1450
|
+
"""
|
|
1451
|
+
The type of the column data.
|
|
1452
|
+
"""
|
|
1453
|
+
return pulumi.get(self, "type")
|
|
1454
|
+
|
|
1455
|
+
@type.setter
|
|
1456
|
+
def type(self, value: Optional[pulumi.Input[Union[str, 'KnownColumnDefinitionType']]]):
|
|
1457
|
+
pulumi.set(self, "type", value)
|
|
1458
|
+
|
|
1459
|
+
|
|
1348
1460
|
if not MYPY:
|
|
1349
1461
|
class ConcurrencyConfigurationArgsDict(TypedDict):
|
|
1350
1462
|
"""
|
|
@@ -1722,238 +1834,1158 @@ class ConditionArgs:
|
|
|
1722
1834
|
|
|
1723
1835
|
|
|
1724
1836
|
if not MYPY:
|
|
1725
|
-
class
|
|
1726
|
-
"""
|
|
1727
|
-
Dimension splitting and filtering definition
|
|
1728
|
-
"""
|
|
1729
|
-
name: pulumi.Input[str]
|
|
1730
|
-
"""
|
|
1731
|
-
Name of the dimension
|
|
1732
|
-
"""
|
|
1733
|
-
operator: pulumi.Input[Union[str, 'DimensionOperator']]
|
|
1837
|
+
class DataCollectionEndpointNetworkAclsArgsDict(TypedDict):
|
|
1734
1838
|
"""
|
|
1735
|
-
|
|
1839
|
+
Network access control rules for the endpoints.
|
|
1736
1840
|
"""
|
|
1737
|
-
|
|
1841
|
+
public_network_access: NotRequired[pulumi.Input[Union[str, 'KnownPublicNetworkAccessOptions']]]
|
|
1738
1842
|
"""
|
|
1739
|
-
|
|
1843
|
+
The configuration to set whether network access from public internet to the endpoints are allowed.
|
|
1740
1844
|
"""
|
|
1741
1845
|
elif False:
|
|
1742
|
-
|
|
1846
|
+
DataCollectionEndpointNetworkAclsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1743
1847
|
|
|
1744
1848
|
@pulumi.input_type
|
|
1745
|
-
class
|
|
1849
|
+
class DataCollectionEndpointNetworkAclsArgs:
|
|
1746
1850
|
def __init__(__self__, *,
|
|
1747
|
-
|
|
1748
|
-
operator: pulumi.Input[Union[str, 'DimensionOperator']],
|
|
1749
|
-
values: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1851
|
+
public_network_access: Optional[pulumi.Input[Union[str, 'KnownPublicNetworkAccessOptions']]] = None):
|
|
1750
1852
|
"""
|
|
1751
|
-
|
|
1752
|
-
:param pulumi.Input[str]
|
|
1753
|
-
:param pulumi.Input[Union[str, 'DimensionOperator']] operator: Operator for dimension values
|
|
1754
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: List of dimension values
|
|
1853
|
+
Network access control rules for the endpoints.
|
|
1854
|
+
:param pulumi.Input[Union[str, 'KnownPublicNetworkAccessOptions']] public_network_access: The configuration to set whether network access from public internet to the endpoints are allowed.
|
|
1755
1855
|
"""
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
pulumi.set(__self__, "values", values)
|
|
1856
|
+
if public_network_access is not None:
|
|
1857
|
+
pulumi.set(__self__, "public_network_access", public_network_access)
|
|
1759
1858
|
|
|
1760
1859
|
@property
|
|
1761
|
-
@pulumi.getter
|
|
1762
|
-
def
|
|
1860
|
+
@pulumi.getter(name="publicNetworkAccess")
|
|
1861
|
+
def public_network_access(self) -> Optional[pulumi.Input[Union[str, 'KnownPublicNetworkAccessOptions']]]:
|
|
1763
1862
|
"""
|
|
1764
|
-
|
|
1863
|
+
The configuration to set whether network access from public internet to the endpoints are allowed.
|
|
1765
1864
|
"""
|
|
1766
|
-
return pulumi.get(self, "
|
|
1865
|
+
return pulumi.get(self, "public_network_access")
|
|
1767
1866
|
|
|
1768
|
-
@
|
|
1769
|
-
def
|
|
1770
|
-
pulumi.set(self, "
|
|
1867
|
+
@public_network_access.setter
|
|
1868
|
+
def public_network_access(self, value: Optional[pulumi.Input[Union[str, 'KnownPublicNetworkAccessOptions']]]):
|
|
1869
|
+
pulumi.set(self, "public_network_access", value)
|
|
1870
|
+
|
|
1871
|
+
|
|
1872
|
+
if not MYPY:
|
|
1873
|
+
class DataCollectionEndpointResourceIdentityArgsDict(TypedDict):
|
|
1874
|
+
"""
|
|
1875
|
+
Managed service identity of the resource.
|
|
1876
|
+
"""
|
|
1877
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]
|
|
1878
|
+
"""
|
|
1879
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
1880
|
+
"""
|
|
1881
|
+
user_assigned_identities: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1882
|
+
"""
|
|
1883
|
+
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.
|
|
1884
|
+
"""
|
|
1885
|
+
elif False:
|
|
1886
|
+
DataCollectionEndpointResourceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
1887
|
+
|
|
1888
|
+
@pulumi.input_type
|
|
1889
|
+
class DataCollectionEndpointResourceIdentityArgs:
|
|
1890
|
+
def __init__(__self__, *,
|
|
1891
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']],
|
|
1892
|
+
user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1893
|
+
"""
|
|
1894
|
+
Managed service identity of the resource.
|
|
1895
|
+
:param pulumi.Input[Union[str, 'ManagedServiceIdentityType']] type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
1896
|
+
: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.
|
|
1897
|
+
"""
|
|
1898
|
+
pulumi.set(__self__, "type", type)
|
|
1899
|
+
if user_assigned_identities is not None:
|
|
1900
|
+
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
|
|
1771
1901
|
|
|
1772
1902
|
@property
|
|
1773
1903
|
@pulumi.getter
|
|
1774
|
-
def
|
|
1904
|
+
def type(self) -> pulumi.Input[Union[str, 'ManagedServiceIdentityType']]:
|
|
1775
1905
|
"""
|
|
1776
|
-
|
|
1906
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
1777
1907
|
"""
|
|
1778
|
-
return pulumi.get(self, "
|
|
1908
|
+
return pulumi.get(self, "type")
|
|
1779
1909
|
|
|
1780
|
-
@
|
|
1781
|
-
def
|
|
1782
|
-
pulumi.set(self, "
|
|
1910
|
+
@type.setter
|
|
1911
|
+
def type(self, value: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]):
|
|
1912
|
+
pulumi.set(self, "type", value)
|
|
1783
1913
|
|
|
1784
1914
|
@property
|
|
1785
|
-
@pulumi.getter
|
|
1786
|
-
def
|
|
1915
|
+
@pulumi.getter(name="userAssignedIdentities")
|
|
1916
|
+
def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1787
1917
|
"""
|
|
1788
|
-
|
|
1918
|
+
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.
|
|
1789
1919
|
"""
|
|
1790
|
-
return pulumi.get(self, "
|
|
1920
|
+
return pulumi.get(self, "user_assigned_identities")
|
|
1791
1921
|
|
|
1792
|
-
@
|
|
1793
|
-
def
|
|
1794
|
-
pulumi.set(self, "
|
|
1922
|
+
@user_assigned_identities.setter
|
|
1923
|
+
def user_assigned_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1924
|
+
pulumi.set(self, "user_assigned_identities", value)
|
|
1795
1925
|
|
|
1796
1926
|
|
|
1797
1927
|
if not MYPY:
|
|
1798
|
-
class
|
|
1928
|
+
class DataCollectionRuleDataSourcesArgsDict(TypedDict):
|
|
1799
1929
|
"""
|
|
1800
|
-
|
|
1930
|
+
The specification of data sources.
|
|
1931
|
+
This property is optional and can be omitted if the rule is meant to be used via direct calls to the provisioned endpoint.
|
|
1801
1932
|
"""
|
|
1802
|
-
|
|
1933
|
+
data_imports: NotRequired[pulumi.Input['DataSourcesSpecDataImportsArgsDict']]
|
|
1803
1934
|
"""
|
|
1804
|
-
|
|
1935
|
+
Specifications of pull based data sources
|
|
1805
1936
|
"""
|
|
1806
|
-
|
|
1937
|
+
extensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ExtensionDataSourceArgsDict']]]]
|
|
1807
1938
|
"""
|
|
1808
|
-
|
|
1939
|
+
The list of Azure VM extension data source configurations.
|
|
1809
1940
|
"""
|
|
1810
|
-
|
|
1941
|
+
iis_logs: NotRequired[pulumi.Input[Sequence[pulumi.Input['IisLogsDataSourceArgsDict']]]]
|
|
1811
1942
|
"""
|
|
1812
|
-
|
|
1943
|
+
The list of IIS logs source configurations.
|
|
1944
|
+
"""
|
|
1945
|
+
log_files: NotRequired[pulumi.Input[Sequence[pulumi.Input['LogFilesDataSourceArgsDict']]]]
|
|
1946
|
+
"""
|
|
1947
|
+
The list of Log files source configurations.
|
|
1948
|
+
"""
|
|
1949
|
+
performance_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['PerfCounterDataSourceArgsDict']]]]
|
|
1950
|
+
"""
|
|
1951
|
+
The list of performance counter data source configurations.
|
|
1952
|
+
"""
|
|
1953
|
+
platform_telemetry: NotRequired[pulumi.Input[Sequence[pulumi.Input['PlatformTelemetryDataSourceArgsDict']]]]
|
|
1954
|
+
"""
|
|
1955
|
+
The list of platform telemetry configurations
|
|
1956
|
+
"""
|
|
1957
|
+
prometheus_forwarder: NotRequired[pulumi.Input[Sequence[pulumi.Input['PrometheusForwarderDataSourceArgsDict']]]]
|
|
1958
|
+
"""
|
|
1959
|
+
The list of Prometheus forwarder data source configurations.
|
|
1960
|
+
"""
|
|
1961
|
+
syslog: NotRequired[pulumi.Input[Sequence[pulumi.Input['SyslogDataSourceArgsDict']]]]
|
|
1962
|
+
"""
|
|
1963
|
+
The list of Syslog data source configurations.
|
|
1964
|
+
"""
|
|
1965
|
+
windows_event_logs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WindowsEventLogDataSourceArgsDict']]]]
|
|
1966
|
+
"""
|
|
1967
|
+
The list of Windows Event Log data source configurations.
|
|
1968
|
+
"""
|
|
1969
|
+
windows_firewall_logs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WindowsFirewallLogsDataSourceArgsDict']]]]
|
|
1970
|
+
"""
|
|
1971
|
+
The list of Windows Firewall logs source configurations.
|
|
1813
1972
|
"""
|
|
1814
1973
|
elif False:
|
|
1815
|
-
|
|
1974
|
+
DataCollectionRuleDataSourcesArgsDict: TypeAlias = Mapping[str, Any]
|
|
1816
1975
|
|
|
1817
1976
|
@pulumi.input_type
|
|
1818
|
-
class
|
|
1977
|
+
class DataCollectionRuleDataSourcesArgs:
|
|
1819
1978
|
def __init__(__self__, *,
|
|
1820
|
-
|
|
1821
|
-
|
|
1822
|
-
|
|
1823
|
-
|
|
1824
|
-
|
|
1825
|
-
|
|
1826
|
-
|
|
1827
|
-
|
|
1828
|
-
|
|
1829
|
-
|
|
1830
|
-
|
|
1831
|
-
|
|
1832
|
-
|
|
1833
|
-
|
|
1834
|
-
|
|
1835
|
-
|
|
1836
|
-
|
|
1837
|
-
|
|
1838
|
-
|
|
1979
|
+
data_imports: Optional[pulumi.Input['DataSourcesSpecDataImportsArgs']] = None,
|
|
1980
|
+
extensions: Optional[pulumi.Input[Sequence[pulumi.Input['ExtensionDataSourceArgs']]]] = None,
|
|
1981
|
+
iis_logs: Optional[pulumi.Input[Sequence[pulumi.Input['IisLogsDataSourceArgs']]]] = None,
|
|
1982
|
+
log_files: Optional[pulumi.Input[Sequence[pulumi.Input['LogFilesDataSourceArgs']]]] = None,
|
|
1983
|
+
performance_counters: Optional[pulumi.Input[Sequence[pulumi.Input['PerfCounterDataSourceArgs']]]] = None,
|
|
1984
|
+
platform_telemetry: Optional[pulumi.Input[Sequence[pulumi.Input['PlatformTelemetryDataSourceArgs']]]] = None,
|
|
1985
|
+
prometheus_forwarder: Optional[pulumi.Input[Sequence[pulumi.Input['PrometheusForwarderDataSourceArgs']]]] = None,
|
|
1986
|
+
syslog: Optional[pulumi.Input[Sequence[pulumi.Input['SyslogDataSourceArgs']]]] = None,
|
|
1987
|
+
windows_event_logs: Optional[pulumi.Input[Sequence[pulumi.Input['WindowsEventLogDataSourceArgs']]]] = None,
|
|
1988
|
+
windows_firewall_logs: Optional[pulumi.Input[Sequence[pulumi.Input['WindowsFirewallLogsDataSourceArgs']]]] = None):
|
|
1989
|
+
"""
|
|
1990
|
+
The specification of data sources.
|
|
1991
|
+
This property is optional and can be omitted if the rule is meant to be used via direct calls to the provisioned endpoint.
|
|
1992
|
+
:param pulumi.Input['DataSourcesSpecDataImportsArgs'] data_imports: Specifications of pull based data sources
|
|
1993
|
+
:param pulumi.Input[Sequence[pulumi.Input['ExtensionDataSourceArgs']]] extensions: The list of Azure VM extension data source configurations.
|
|
1994
|
+
:param pulumi.Input[Sequence[pulumi.Input['IisLogsDataSourceArgs']]] iis_logs: The list of IIS logs source configurations.
|
|
1995
|
+
:param pulumi.Input[Sequence[pulumi.Input['LogFilesDataSourceArgs']]] log_files: The list of Log files source configurations.
|
|
1996
|
+
:param pulumi.Input[Sequence[pulumi.Input['PerfCounterDataSourceArgs']]] performance_counters: The list of performance counter data source configurations.
|
|
1997
|
+
:param pulumi.Input[Sequence[pulumi.Input['PlatformTelemetryDataSourceArgs']]] platform_telemetry: The list of platform telemetry configurations
|
|
1998
|
+
:param pulumi.Input[Sequence[pulumi.Input['PrometheusForwarderDataSourceArgs']]] prometheus_forwarder: The list of Prometheus forwarder data source configurations.
|
|
1999
|
+
:param pulumi.Input[Sequence[pulumi.Input['SyslogDataSourceArgs']]] syslog: The list of Syslog data source configurations.
|
|
2000
|
+
:param pulumi.Input[Sequence[pulumi.Input['WindowsEventLogDataSourceArgs']]] windows_event_logs: The list of Windows Event Log data source configurations.
|
|
2001
|
+
:param pulumi.Input[Sequence[pulumi.Input['WindowsFirewallLogsDataSourceArgs']]] windows_firewall_logs: The list of Windows Firewall logs source configurations.
|
|
2002
|
+
"""
|
|
2003
|
+
if data_imports is not None:
|
|
2004
|
+
pulumi.set(__self__, "data_imports", data_imports)
|
|
2005
|
+
if extensions is not None:
|
|
2006
|
+
pulumi.set(__self__, "extensions", extensions)
|
|
2007
|
+
if iis_logs is not None:
|
|
2008
|
+
pulumi.set(__self__, "iis_logs", iis_logs)
|
|
2009
|
+
if log_files is not None:
|
|
2010
|
+
pulumi.set(__self__, "log_files", log_files)
|
|
2011
|
+
if performance_counters is not None:
|
|
2012
|
+
pulumi.set(__self__, "performance_counters", performance_counters)
|
|
2013
|
+
if platform_telemetry is not None:
|
|
2014
|
+
pulumi.set(__self__, "platform_telemetry", platform_telemetry)
|
|
2015
|
+
if prometheus_forwarder is not None:
|
|
2016
|
+
pulumi.set(__self__, "prometheus_forwarder", prometheus_forwarder)
|
|
2017
|
+
if syslog is not None:
|
|
2018
|
+
pulumi.set(__self__, "syslog", syslog)
|
|
2019
|
+
if windows_event_logs is not None:
|
|
2020
|
+
pulumi.set(__self__, "windows_event_logs", windows_event_logs)
|
|
2021
|
+
if windows_firewall_logs is not None:
|
|
2022
|
+
pulumi.set(__self__, "windows_firewall_logs", windows_firewall_logs)
|
|
1839
2023
|
|
|
1840
2024
|
@property
|
|
1841
|
-
@pulumi.getter(name="
|
|
1842
|
-
def
|
|
2025
|
+
@pulumi.getter(name="dataImports")
|
|
2026
|
+
def data_imports(self) -> Optional[pulumi.Input['DataSourcesSpecDataImportsArgs']]:
|
|
1843
2027
|
"""
|
|
1844
|
-
|
|
2028
|
+
Specifications of pull based data sources
|
|
1845
2029
|
"""
|
|
1846
|
-
return pulumi.get(self, "
|
|
2030
|
+
return pulumi.get(self, "data_imports")
|
|
1847
2031
|
|
|
1848
|
-
@
|
|
1849
|
-
def
|
|
1850
|
-
pulumi.set(self, "
|
|
2032
|
+
@data_imports.setter
|
|
2033
|
+
def data_imports(self, value: Optional[pulumi.Input['DataSourcesSpecDataImportsArgs']]):
|
|
2034
|
+
pulumi.set(self, "data_imports", value)
|
|
1851
2035
|
|
|
1852
2036
|
@property
|
|
1853
|
-
@pulumi.getter
|
|
1854
|
-
def
|
|
2037
|
+
@pulumi.getter
|
|
2038
|
+
def extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExtensionDataSourceArgs']]]]:
|
|
1855
2039
|
"""
|
|
1856
|
-
|
|
2040
|
+
The list of Azure VM extension data source configurations.
|
|
1857
2041
|
"""
|
|
1858
|
-
return pulumi.get(self, "
|
|
2042
|
+
return pulumi.get(self, "extensions")
|
|
1859
2043
|
|
|
1860
|
-
@
|
|
1861
|
-
def
|
|
1862
|
-
pulumi.set(self, "
|
|
2044
|
+
@extensions.setter
|
|
2045
|
+
def extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExtensionDataSourceArgs']]]]):
|
|
2046
|
+
pulumi.set(self, "extensions", value)
|
|
1863
2047
|
|
|
1864
2048
|
@property
|
|
1865
|
-
@pulumi.getter(name="
|
|
1866
|
-
def
|
|
2049
|
+
@pulumi.getter(name="iisLogs")
|
|
2050
|
+
def iis_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IisLogsDataSourceArgs']]]]:
|
|
1867
2051
|
"""
|
|
1868
|
-
|
|
2052
|
+
The list of IIS logs source configurations.
|
|
1869
2053
|
"""
|
|
1870
|
-
return pulumi.get(self, "
|
|
1871
|
-
|
|
1872
|
-
@send_to_subscription_co_administrators.setter
|
|
1873
|
-
def send_to_subscription_co_administrators(self, value: Optional[pulumi.Input[bool]]):
|
|
1874
|
-
pulumi.set(self, "send_to_subscription_co_administrators", value)
|
|
2054
|
+
return pulumi.get(self, "iis_logs")
|
|
1875
2055
|
|
|
2056
|
+
@iis_logs.setter
|
|
2057
|
+
def iis_logs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IisLogsDataSourceArgs']]]]):
|
|
2058
|
+
pulumi.set(self, "iis_logs", value)
|
|
1876
2059
|
|
|
1877
|
-
|
|
1878
|
-
|
|
1879
|
-
|
|
1880
|
-
An email receiver.
|
|
1881
|
-
"""
|
|
1882
|
-
email_address: pulumi.Input[str]
|
|
2060
|
+
@property
|
|
2061
|
+
@pulumi.getter(name="logFiles")
|
|
2062
|
+
def log_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LogFilesDataSourceArgs']]]]:
|
|
1883
2063
|
"""
|
|
1884
|
-
The
|
|
2064
|
+
The list of Log files source configurations.
|
|
1885
2065
|
"""
|
|
1886
|
-
|
|
2066
|
+
return pulumi.get(self, "log_files")
|
|
2067
|
+
|
|
2068
|
+
@log_files.setter
|
|
2069
|
+
def log_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LogFilesDataSourceArgs']]]]):
|
|
2070
|
+
pulumi.set(self, "log_files", value)
|
|
2071
|
+
|
|
2072
|
+
@property
|
|
2073
|
+
@pulumi.getter(name="performanceCounters")
|
|
2074
|
+
def performance_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PerfCounterDataSourceArgs']]]]:
|
|
1887
2075
|
"""
|
|
1888
|
-
The
|
|
2076
|
+
The list of performance counter data source configurations.
|
|
1889
2077
|
"""
|
|
1890
|
-
|
|
2078
|
+
return pulumi.get(self, "performance_counters")
|
|
2079
|
+
|
|
2080
|
+
@performance_counters.setter
|
|
2081
|
+
def performance_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PerfCounterDataSourceArgs']]]]):
|
|
2082
|
+
pulumi.set(self, "performance_counters", value)
|
|
2083
|
+
|
|
2084
|
+
@property
|
|
2085
|
+
@pulumi.getter(name="platformTelemetry")
|
|
2086
|
+
def platform_telemetry(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PlatformTelemetryDataSourceArgs']]]]:
|
|
1891
2087
|
"""
|
|
1892
|
-
|
|
2088
|
+
The list of platform telemetry configurations
|
|
1893
2089
|
"""
|
|
1894
|
-
|
|
1895
|
-
EmailReceiverArgsDict: TypeAlias = Mapping[str, Any]
|
|
2090
|
+
return pulumi.get(self, "platform_telemetry")
|
|
1896
2091
|
|
|
1897
|
-
@
|
|
1898
|
-
|
|
1899
|
-
|
|
1900
|
-
|
|
1901
|
-
|
|
1902
|
-
|
|
2092
|
+
@platform_telemetry.setter
|
|
2093
|
+
def platform_telemetry(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PlatformTelemetryDataSourceArgs']]]]):
|
|
2094
|
+
pulumi.set(self, "platform_telemetry", value)
|
|
2095
|
+
|
|
2096
|
+
@property
|
|
2097
|
+
@pulumi.getter(name="prometheusForwarder")
|
|
2098
|
+
def prometheus_forwarder(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PrometheusForwarderDataSourceArgs']]]]:
|
|
1903
2099
|
"""
|
|
1904
|
-
|
|
1905
|
-
:param pulumi.Input[str] email_address: The email address of this receiver.
|
|
1906
|
-
:param pulumi.Input[str] name: The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
1907
|
-
:param pulumi.Input[bool] use_common_alert_schema: Indicates whether to use common alert schema.
|
|
2100
|
+
The list of Prometheus forwarder data source configurations.
|
|
1908
2101
|
"""
|
|
1909
|
-
pulumi.
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
|
|
1913
|
-
|
|
1914
|
-
pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
|
|
2102
|
+
return pulumi.get(self, "prometheus_forwarder")
|
|
2103
|
+
|
|
2104
|
+
@prometheus_forwarder.setter
|
|
2105
|
+
def prometheus_forwarder(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PrometheusForwarderDataSourceArgs']]]]):
|
|
2106
|
+
pulumi.set(self, "prometheus_forwarder", value)
|
|
1915
2107
|
|
|
1916
2108
|
@property
|
|
1917
|
-
@pulumi.getter
|
|
1918
|
-
def
|
|
2109
|
+
@pulumi.getter
|
|
2110
|
+
def syslog(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SyslogDataSourceArgs']]]]:
|
|
1919
2111
|
"""
|
|
1920
|
-
The
|
|
2112
|
+
The list of Syslog data source configurations.
|
|
1921
2113
|
"""
|
|
1922
|
-
return pulumi.get(self, "
|
|
2114
|
+
return pulumi.get(self, "syslog")
|
|
1923
2115
|
|
|
1924
|
-
@
|
|
1925
|
-
def
|
|
1926
|
-
pulumi.set(self, "
|
|
2116
|
+
@syslog.setter
|
|
2117
|
+
def syslog(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SyslogDataSourceArgs']]]]):
|
|
2118
|
+
pulumi.set(self, "syslog", value)
|
|
1927
2119
|
|
|
1928
2120
|
@property
|
|
1929
|
-
@pulumi.getter
|
|
1930
|
-
def
|
|
2121
|
+
@pulumi.getter(name="windowsEventLogs")
|
|
2122
|
+
def windows_event_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WindowsEventLogDataSourceArgs']]]]:
|
|
1931
2123
|
"""
|
|
1932
|
-
The
|
|
2124
|
+
The list of Windows Event Log data source configurations.
|
|
1933
2125
|
"""
|
|
1934
|
-
return pulumi.get(self, "
|
|
2126
|
+
return pulumi.get(self, "windows_event_logs")
|
|
1935
2127
|
|
|
1936
|
-
@
|
|
1937
|
-
def
|
|
1938
|
-
pulumi.set(self, "
|
|
2128
|
+
@windows_event_logs.setter
|
|
2129
|
+
def windows_event_logs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WindowsEventLogDataSourceArgs']]]]):
|
|
2130
|
+
pulumi.set(self, "windows_event_logs", value)
|
|
1939
2131
|
|
|
1940
2132
|
@property
|
|
1941
|
-
@pulumi.getter(name="
|
|
1942
|
-
def
|
|
2133
|
+
@pulumi.getter(name="windowsFirewallLogs")
|
|
2134
|
+
def windows_firewall_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WindowsFirewallLogsDataSourceArgs']]]]:
|
|
1943
2135
|
"""
|
|
1944
|
-
|
|
2136
|
+
The list of Windows Firewall logs source configurations.
|
|
1945
2137
|
"""
|
|
1946
|
-
return pulumi.get(self, "
|
|
2138
|
+
return pulumi.get(self, "windows_firewall_logs")
|
|
1947
2139
|
|
|
1948
|
-
@
|
|
1949
|
-
def
|
|
1950
|
-
pulumi.set(self, "
|
|
2140
|
+
@windows_firewall_logs.setter
|
|
2141
|
+
def windows_firewall_logs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WindowsFirewallLogsDataSourceArgs']]]]):
|
|
2142
|
+
pulumi.set(self, "windows_firewall_logs", value)
|
|
1951
2143
|
|
|
1952
2144
|
|
|
1953
2145
|
if not MYPY:
|
|
1954
|
-
class
|
|
2146
|
+
class DataCollectionRuleDestinationsArgsDict(TypedDict):
|
|
1955
2147
|
"""
|
|
1956
|
-
|
|
2148
|
+
The specification of destinations.
|
|
2149
|
+
"""
|
|
2150
|
+
azure_monitor_metrics: NotRequired[pulumi.Input['DestinationsSpecAzureMonitorMetricsArgsDict']]
|
|
2151
|
+
"""
|
|
2152
|
+
Azure Monitor Metrics destination.
|
|
2153
|
+
"""
|
|
2154
|
+
event_hubs: NotRequired[pulumi.Input[Sequence[pulumi.Input['EventHubDestinationArgsDict']]]]
|
|
2155
|
+
"""
|
|
2156
|
+
List of Event Hubs destinations.
|
|
2157
|
+
"""
|
|
2158
|
+
event_hubs_direct: NotRequired[pulumi.Input[Sequence[pulumi.Input['EventHubDirectDestinationArgsDict']]]]
|
|
2159
|
+
"""
|
|
2160
|
+
List of Event Hubs Direct destinations.
|
|
2161
|
+
"""
|
|
2162
|
+
log_analytics: NotRequired[pulumi.Input[Sequence[pulumi.Input['LogAnalyticsDestinationArgsDict']]]]
|
|
2163
|
+
"""
|
|
2164
|
+
List of Log Analytics destinations.
|
|
2165
|
+
"""
|
|
2166
|
+
monitoring_accounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['MonitoringAccountDestinationArgsDict']]]]
|
|
2167
|
+
"""
|
|
2168
|
+
List of monitoring account destinations.
|
|
2169
|
+
"""
|
|
2170
|
+
storage_accounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgsDict']]]]
|
|
2171
|
+
"""
|
|
2172
|
+
List of storage accounts destinations.
|
|
2173
|
+
"""
|
|
2174
|
+
storage_blobs_direct: NotRequired[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgsDict']]]]
|
|
2175
|
+
"""
|
|
2176
|
+
List of Storage Blob Direct destinations. To be used only for sending data directly to store from the agent.
|
|
2177
|
+
"""
|
|
2178
|
+
storage_tables_direct: NotRequired[pulumi.Input[Sequence[pulumi.Input['StorageTableDestinationArgsDict']]]]
|
|
2179
|
+
"""
|
|
2180
|
+
List of Storage Table Direct destinations.
|
|
2181
|
+
"""
|
|
2182
|
+
elif False:
|
|
2183
|
+
DataCollectionRuleDestinationsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2184
|
+
|
|
2185
|
+
@pulumi.input_type
|
|
2186
|
+
class DataCollectionRuleDestinationsArgs:
|
|
2187
|
+
def __init__(__self__, *,
|
|
2188
|
+
azure_monitor_metrics: Optional[pulumi.Input['DestinationsSpecAzureMonitorMetricsArgs']] = None,
|
|
2189
|
+
event_hubs: Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDestinationArgs']]]] = None,
|
|
2190
|
+
event_hubs_direct: Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDirectDestinationArgs']]]] = None,
|
|
2191
|
+
log_analytics: Optional[pulumi.Input[Sequence[pulumi.Input['LogAnalyticsDestinationArgs']]]] = None,
|
|
2192
|
+
monitoring_accounts: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringAccountDestinationArgs']]]] = None,
|
|
2193
|
+
storage_accounts: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]] = None,
|
|
2194
|
+
storage_blobs_direct: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]] = None,
|
|
2195
|
+
storage_tables_direct: Optional[pulumi.Input[Sequence[pulumi.Input['StorageTableDestinationArgs']]]] = None):
|
|
2196
|
+
"""
|
|
2197
|
+
The specification of destinations.
|
|
2198
|
+
:param pulumi.Input['DestinationsSpecAzureMonitorMetricsArgs'] azure_monitor_metrics: Azure Monitor Metrics destination.
|
|
2199
|
+
:param pulumi.Input[Sequence[pulumi.Input['EventHubDestinationArgs']]] event_hubs: List of Event Hubs destinations.
|
|
2200
|
+
:param pulumi.Input[Sequence[pulumi.Input['EventHubDirectDestinationArgs']]] event_hubs_direct: List of Event Hubs Direct destinations.
|
|
2201
|
+
:param pulumi.Input[Sequence[pulumi.Input['LogAnalyticsDestinationArgs']]] log_analytics: List of Log Analytics destinations.
|
|
2202
|
+
:param pulumi.Input[Sequence[pulumi.Input['MonitoringAccountDestinationArgs']]] monitoring_accounts: List of monitoring account destinations.
|
|
2203
|
+
:param pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]] storage_accounts: List of storage accounts destinations.
|
|
2204
|
+
:param pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]] storage_blobs_direct: List of Storage Blob Direct destinations. To be used only for sending data directly to store from the agent.
|
|
2205
|
+
:param pulumi.Input[Sequence[pulumi.Input['StorageTableDestinationArgs']]] storage_tables_direct: List of Storage Table Direct destinations.
|
|
2206
|
+
"""
|
|
2207
|
+
if azure_monitor_metrics is not None:
|
|
2208
|
+
pulumi.set(__self__, "azure_monitor_metrics", azure_monitor_metrics)
|
|
2209
|
+
if event_hubs is not None:
|
|
2210
|
+
pulumi.set(__self__, "event_hubs", event_hubs)
|
|
2211
|
+
if event_hubs_direct is not None:
|
|
2212
|
+
pulumi.set(__self__, "event_hubs_direct", event_hubs_direct)
|
|
2213
|
+
if log_analytics is not None:
|
|
2214
|
+
pulumi.set(__self__, "log_analytics", log_analytics)
|
|
2215
|
+
if monitoring_accounts is not None:
|
|
2216
|
+
pulumi.set(__self__, "monitoring_accounts", monitoring_accounts)
|
|
2217
|
+
if storage_accounts is not None:
|
|
2218
|
+
pulumi.set(__self__, "storage_accounts", storage_accounts)
|
|
2219
|
+
if storage_blobs_direct is not None:
|
|
2220
|
+
pulumi.set(__self__, "storage_blobs_direct", storage_blobs_direct)
|
|
2221
|
+
if storage_tables_direct is not None:
|
|
2222
|
+
pulumi.set(__self__, "storage_tables_direct", storage_tables_direct)
|
|
2223
|
+
|
|
2224
|
+
@property
|
|
2225
|
+
@pulumi.getter(name="azureMonitorMetrics")
|
|
2226
|
+
def azure_monitor_metrics(self) -> Optional[pulumi.Input['DestinationsSpecAzureMonitorMetricsArgs']]:
|
|
2227
|
+
"""
|
|
2228
|
+
Azure Monitor Metrics destination.
|
|
2229
|
+
"""
|
|
2230
|
+
return pulumi.get(self, "azure_monitor_metrics")
|
|
2231
|
+
|
|
2232
|
+
@azure_monitor_metrics.setter
|
|
2233
|
+
def azure_monitor_metrics(self, value: Optional[pulumi.Input['DestinationsSpecAzureMonitorMetricsArgs']]):
|
|
2234
|
+
pulumi.set(self, "azure_monitor_metrics", value)
|
|
2235
|
+
|
|
2236
|
+
@property
|
|
2237
|
+
@pulumi.getter(name="eventHubs")
|
|
2238
|
+
def event_hubs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDestinationArgs']]]]:
|
|
2239
|
+
"""
|
|
2240
|
+
List of Event Hubs destinations.
|
|
2241
|
+
"""
|
|
2242
|
+
return pulumi.get(self, "event_hubs")
|
|
2243
|
+
|
|
2244
|
+
@event_hubs.setter
|
|
2245
|
+
def event_hubs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDestinationArgs']]]]):
|
|
2246
|
+
pulumi.set(self, "event_hubs", value)
|
|
2247
|
+
|
|
2248
|
+
@property
|
|
2249
|
+
@pulumi.getter(name="eventHubsDirect")
|
|
2250
|
+
def event_hubs_direct(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDirectDestinationArgs']]]]:
|
|
2251
|
+
"""
|
|
2252
|
+
List of Event Hubs Direct destinations.
|
|
2253
|
+
"""
|
|
2254
|
+
return pulumi.get(self, "event_hubs_direct")
|
|
2255
|
+
|
|
2256
|
+
@event_hubs_direct.setter
|
|
2257
|
+
def event_hubs_direct(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EventHubDirectDestinationArgs']]]]):
|
|
2258
|
+
pulumi.set(self, "event_hubs_direct", value)
|
|
2259
|
+
|
|
2260
|
+
@property
|
|
2261
|
+
@pulumi.getter(name="logAnalytics")
|
|
2262
|
+
def log_analytics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LogAnalyticsDestinationArgs']]]]:
|
|
2263
|
+
"""
|
|
2264
|
+
List of Log Analytics destinations.
|
|
2265
|
+
"""
|
|
2266
|
+
return pulumi.get(self, "log_analytics")
|
|
2267
|
+
|
|
2268
|
+
@log_analytics.setter
|
|
2269
|
+
def log_analytics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LogAnalyticsDestinationArgs']]]]):
|
|
2270
|
+
pulumi.set(self, "log_analytics", value)
|
|
2271
|
+
|
|
2272
|
+
@property
|
|
2273
|
+
@pulumi.getter(name="monitoringAccounts")
|
|
2274
|
+
def monitoring_accounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringAccountDestinationArgs']]]]:
|
|
2275
|
+
"""
|
|
2276
|
+
List of monitoring account destinations.
|
|
2277
|
+
"""
|
|
2278
|
+
return pulumi.get(self, "monitoring_accounts")
|
|
2279
|
+
|
|
2280
|
+
@monitoring_accounts.setter
|
|
2281
|
+
def monitoring_accounts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringAccountDestinationArgs']]]]):
|
|
2282
|
+
pulumi.set(self, "monitoring_accounts", value)
|
|
2283
|
+
|
|
2284
|
+
@property
|
|
2285
|
+
@pulumi.getter(name="storageAccounts")
|
|
2286
|
+
def storage_accounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]]:
|
|
2287
|
+
"""
|
|
2288
|
+
List of storage accounts destinations.
|
|
2289
|
+
"""
|
|
2290
|
+
return pulumi.get(self, "storage_accounts")
|
|
2291
|
+
|
|
2292
|
+
@storage_accounts.setter
|
|
2293
|
+
def storage_accounts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]]):
|
|
2294
|
+
pulumi.set(self, "storage_accounts", value)
|
|
2295
|
+
|
|
2296
|
+
@property
|
|
2297
|
+
@pulumi.getter(name="storageBlobsDirect")
|
|
2298
|
+
def storage_blobs_direct(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]]:
|
|
2299
|
+
"""
|
|
2300
|
+
List of Storage Blob Direct destinations. To be used only for sending data directly to store from the agent.
|
|
2301
|
+
"""
|
|
2302
|
+
return pulumi.get(self, "storage_blobs_direct")
|
|
2303
|
+
|
|
2304
|
+
@storage_blobs_direct.setter
|
|
2305
|
+
def storage_blobs_direct(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBlobDestinationArgs']]]]):
|
|
2306
|
+
pulumi.set(self, "storage_blobs_direct", value)
|
|
2307
|
+
|
|
2308
|
+
@property
|
|
2309
|
+
@pulumi.getter(name="storageTablesDirect")
|
|
2310
|
+
def storage_tables_direct(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageTableDestinationArgs']]]]:
|
|
2311
|
+
"""
|
|
2312
|
+
List of Storage Table Direct destinations.
|
|
2313
|
+
"""
|
|
2314
|
+
return pulumi.get(self, "storage_tables_direct")
|
|
2315
|
+
|
|
2316
|
+
@storage_tables_direct.setter
|
|
2317
|
+
def storage_tables_direct(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageTableDestinationArgs']]]]):
|
|
2318
|
+
pulumi.set(self, "storage_tables_direct", value)
|
|
2319
|
+
|
|
2320
|
+
|
|
2321
|
+
if not MYPY:
|
|
2322
|
+
class DataCollectionRuleResourceIdentityArgsDict(TypedDict):
|
|
2323
|
+
"""
|
|
2324
|
+
Managed service identity of the resource.
|
|
2325
|
+
"""
|
|
2326
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]
|
|
2327
|
+
"""
|
|
2328
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
2329
|
+
"""
|
|
2330
|
+
user_assigned_identities: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2331
|
+
"""
|
|
2332
|
+
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.
|
|
2333
|
+
"""
|
|
2334
|
+
elif False:
|
|
2335
|
+
DataCollectionRuleResourceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
2336
|
+
|
|
2337
|
+
@pulumi.input_type
|
|
2338
|
+
class DataCollectionRuleResourceIdentityArgs:
|
|
2339
|
+
def __init__(__self__, *,
|
|
2340
|
+
type: pulumi.Input[Union[str, 'ManagedServiceIdentityType']],
|
|
2341
|
+
user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2342
|
+
"""
|
|
2343
|
+
Managed service identity of the resource.
|
|
2344
|
+
:param pulumi.Input[Union[str, 'ManagedServiceIdentityType']] type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
2345
|
+
: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.
|
|
2346
|
+
"""
|
|
2347
|
+
pulumi.set(__self__, "type", type)
|
|
2348
|
+
if user_assigned_identities is not None:
|
|
2349
|
+
pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
|
|
2350
|
+
|
|
2351
|
+
@property
|
|
2352
|
+
@pulumi.getter
|
|
2353
|
+
def type(self) -> pulumi.Input[Union[str, 'ManagedServiceIdentityType']]:
|
|
2354
|
+
"""
|
|
2355
|
+
Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
|
|
2356
|
+
"""
|
|
2357
|
+
return pulumi.get(self, "type")
|
|
2358
|
+
|
|
2359
|
+
@type.setter
|
|
2360
|
+
def type(self, value: pulumi.Input[Union[str, 'ManagedServiceIdentityType']]):
|
|
2361
|
+
pulumi.set(self, "type", value)
|
|
2362
|
+
|
|
2363
|
+
@property
|
|
2364
|
+
@pulumi.getter(name="userAssignedIdentities")
|
|
2365
|
+
def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2366
|
+
"""
|
|
2367
|
+
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.
|
|
2368
|
+
"""
|
|
2369
|
+
return pulumi.get(self, "user_assigned_identities")
|
|
2370
|
+
|
|
2371
|
+
@user_assigned_identities.setter
|
|
2372
|
+
def user_assigned_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2373
|
+
pulumi.set(self, "user_assigned_identities", value)
|
|
2374
|
+
|
|
2375
|
+
|
|
2376
|
+
if not MYPY:
|
|
2377
|
+
class DataFlowArgsDict(TypedDict):
|
|
2378
|
+
"""
|
|
2379
|
+
Definition of which streams are sent to which destinations.
|
|
2380
|
+
"""
|
|
2381
|
+
built_in_transform: NotRequired[pulumi.Input[str]]
|
|
2382
|
+
"""
|
|
2383
|
+
The builtIn transform to transform stream data
|
|
2384
|
+
"""
|
|
2385
|
+
destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2386
|
+
"""
|
|
2387
|
+
List of destinations for this data flow.
|
|
2388
|
+
"""
|
|
2389
|
+
output_stream: NotRequired[pulumi.Input[str]]
|
|
2390
|
+
"""
|
|
2391
|
+
The output stream of the transform. Only required if the transform changes data to a different stream.
|
|
2392
|
+
"""
|
|
2393
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownDataFlowStreams']]]]]
|
|
2394
|
+
"""
|
|
2395
|
+
List of streams for this data flow.
|
|
2396
|
+
"""
|
|
2397
|
+
transform_kql: NotRequired[pulumi.Input[str]]
|
|
2398
|
+
"""
|
|
2399
|
+
The KQL query to transform stream data.
|
|
2400
|
+
"""
|
|
2401
|
+
elif False:
|
|
2402
|
+
DataFlowArgsDict: TypeAlias = Mapping[str, Any]
|
|
2403
|
+
|
|
2404
|
+
@pulumi.input_type
|
|
2405
|
+
class DataFlowArgs:
|
|
2406
|
+
def __init__(__self__, *,
|
|
2407
|
+
built_in_transform: Optional[pulumi.Input[str]] = None,
|
|
2408
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2409
|
+
output_stream: Optional[pulumi.Input[str]] = None,
|
|
2410
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownDataFlowStreams']]]]] = None,
|
|
2411
|
+
transform_kql: Optional[pulumi.Input[str]] = None):
|
|
2412
|
+
"""
|
|
2413
|
+
Definition of which streams are sent to which destinations.
|
|
2414
|
+
:param pulumi.Input[str] built_in_transform: The builtIn transform to transform stream data
|
|
2415
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] destinations: List of destinations for this data flow.
|
|
2416
|
+
:param pulumi.Input[str] output_stream: The output stream of the transform. Only required if the transform changes data to a different stream.
|
|
2417
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownDataFlowStreams']]]] streams: List of streams for this data flow.
|
|
2418
|
+
:param pulumi.Input[str] transform_kql: The KQL query to transform stream data.
|
|
2419
|
+
"""
|
|
2420
|
+
if built_in_transform is not None:
|
|
2421
|
+
pulumi.set(__self__, "built_in_transform", built_in_transform)
|
|
2422
|
+
if destinations is not None:
|
|
2423
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
2424
|
+
if output_stream is not None:
|
|
2425
|
+
pulumi.set(__self__, "output_stream", output_stream)
|
|
2426
|
+
if streams is not None:
|
|
2427
|
+
pulumi.set(__self__, "streams", streams)
|
|
2428
|
+
if transform_kql is not None:
|
|
2429
|
+
pulumi.set(__self__, "transform_kql", transform_kql)
|
|
2430
|
+
|
|
2431
|
+
@property
|
|
2432
|
+
@pulumi.getter(name="builtInTransform")
|
|
2433
|
+
def built_in_transform(self) -> Optional[pulumi.Input[str]]:
|
|
2434
|
+
"""
|
|
2435
|
+
The builtIn transform to transform stream data
|
|
2436
|
+
"""
|
|
2437
|
+
return pulumi.get(self, "built_in_transform")
|
|
2438
|
+
|
|
2439
|
+
@built_in_transform.setter
|
|
2440
|
+
def built_in_transform(self, value: Optional[pulumi.Input[str]]):
|
|
2441
|
+
pulumi.set(self, "built_in_transform", value)
|
|
2442
|
+
|
|
2443
|
+
@property
|
|
2444
|
+
@pulumi.getter
|
|
2445
|
+
def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2446
|
+
"""
|
|
2447
|
+
List of destinations for this data flow.
|
|
2448
|
+
"""
|
|
2449
|
+
return pulumi.get(self, "destinations")
|
|
2450
|
+
|
|
2451
|
+
@destinations.setter
|
|
2452
|
+
def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2453
|
+
pulumi.set(self, "destinations", value)
|
|
2454
|
+
|
|
2455
|
+
@property
|
|
2456
|
+
@pulumi.getter(name="outputStream")
|
|
2457
|
+
def output_stream(self) -> Optional[pulumi.Input[str]]:
|
|
2458
|
+
"""
|
|
2459
|
+
The output stream of the transform. Only required if the transform changes data to a different stream.
|
|
2460
|
+
"""
|
|
2461
|
+
return pulumi.get(self, "output_stream")
|
|
2462
|
+
|
|
2463
|
+
@output_stream.setter
|
|
2464
|
+
def output_stream(self, value: Optional[pulumi.Input[str]]):
|
|
2465
|
+
pulumi.set(self, "output_stream", value)
|
|
2466
|
+
|
|
2467
|
+
@property
|
|
2468
|
+
@pulumi.getter
|
|
2469
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownDataFlowStreams']]]]]:
|
|
2470
|
+
"""
|
|
2471
|
+
List of streams for this data flow.
|
|
2472
|
+
"""
|
|
2473
|
+
return pulumi.get(self, "streams")
|
|
2474
|
+
|
|
2475
|
+
@streams.setter
|
|
2476
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownDataFlowStreams']]]]]):
|
|
2477
|
+
pulumi.set(self, "streams", value)
|
|
2478
|
+
|
|
2479
|
+
@property
|
|
2480
|
+
@pulumi.getter(name="transformKql")
|
|
2481
|
+
def transform_kql(self) -> Optional[pulumi.Input[str]]:
|
|
2482
|
+
"""
|
|
2483
|
+
The KQL query to transform stream data.
|
|
2484
|
+
"""
|
|
2485
|
+
return pulumi.get(self, "transform_kql")
|
|
2486
|
+
|
|
2487
|
+
@transform_kql.setter
|
|
2488
|
+
def transform_kql(self, value: Optional[pulumi.Input[str]]):
|
|
2489
|
+
pulumi.set(self, "transform_kql", value)
|
|
2490
|
+
|
|
2491
|
+
|
|
2492
|
+
if not MYPY:
|
|
2493
|
+
class DataImportSourcesEventHubArgsDict(TypedDict):
|
|
2494
|
+
"""
|
|
2495
|
+
Definition of Event Hub configuration.
|
|
2496
|
+
"""
|
|
2497
|
+
consumer_group: NotRequired[pulumi.Input[str]]
|
|
2498
|
+
"""
|
|
2499
|
+
Event Hub consumer group name
|
|
2500
|
+
"""
|
|
2501
|
+
name: NotRequired[pulumi.Input[str]]
|
|
2502
|
+
"""
|
|
2503
|
+
A friendly name for the data source.
|
|
2504
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
2505
|
+
"""
|
|
2506
|
+
stream: NotRequired[pulumi.Input[str]]
|
|
2507
|
+
"""
|
|
2508
|
+
The stream to collect from EventHub
|
|
2509
|
+
"""
|
|
2510
|
+
elif False:
|
|
2511
|
+
DataImportSourcesEventHubArgsDict: TypeAlias = Mapping[str, Any]
|
|
2512
|
+
|
|
2513
|
+
@pulumi.input_type
|
|
2514
|
+
class DataImportSourcesEventHubArgs:
|
|
2515
|
+
def __init__(__self__, *,
|
|
2516
|
+
consumer_group: Optional[pulumi.Input[str]] = None,
|
|
2517
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
2518
|
+
stream: Optional[pulumi.Input[str]] = None):
|
|
2519
|
+
"""
|
|
2520
|
+
Definition of Event Hub configuration.
|
|
2521
|
+
:param pulumi.Input[str] consumer_group: Event Hub consumer group name
|
|
2522
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
2523
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
2524
|
+
:param pulumi.Input[str] stream: The stream to collect from EventHub
|
|
2525
|
+
"""
|
|
2526
|
+
if consumer_group is not None:
|
|
2527
|
+
pulumi.set(__self__, "consumer_group", consumer_group)
|
|
2528
|
+
if name is not None:
|
|
2529
|
+
pulumi.set(__self__, "name", name)
|
|
2530
|
+
if stream is not None:
|
|
2531
|
+
pulumi.set(__self__, "stream", stream)
|
|
2532
|
+
|
|
2533
|
+
@property
|
|
2534
|
+
@pulumi.getter(name="consumerGroup")
|
|
2535
|
+
def consumer_group(self) -> Optional[pulumi.Input[str]]:
|
|
2536
|
+
"""
|
|
2537
|
+
Event Hub consumer group name
|
|
2538
|
+
"""
|
|
2539
|
+
return pulumi.get(self, "consumer_group")
|
|
2540
|
+
|
|
2541
|
+
@consumer_group.setter
|
|
2542
|
+
def consumer_group(self, value: Optional[pulumi.Input[str]]):
|
|
2543
|
+
pulumi.set(self, "consumer_group", value)
|
|
2544
|
+
|
|
2545
|
+
@property
|
|
2546
|
+
@pulumi.getter
|
|
2547
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2548
|
+
"""
|
|
2549
|
+
A friendly name for the data source.
|
|
2550
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
2551
|
+
"""
|
|
2552
|
+
return pulumi.get(self, "name")
|
|
2553
|
+
|
|
2554
|
+
@name.setter
|
|
2555
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2556
|
+
pulumi.set(self, "name", value)
|
|
2557
|
+
|
|
2558
|
+
@property
|
|
2559
|
+
@pulumi.getter
|
|
2560
|
+
def stream(self) -> Optional[pulumi.Input[str]]:
|
|
2561
|
+
"""
|
|
2562
|
+
The stream to collect from EventHub
|
|
2563
|
+
"""
|
|
2564
|
+
return pulumi.get(self, "stream")
|
|
2565
|
+
|
|
2566
|
+
@stream.setter
|
|
2567
|
+
def stream(self, value: Optional[pulumi.Input[str]]):
|
|
2568
|
+
pulumi.set(self, "stream", value)
|
|
2569
|
+
|
|
2570
|
+
|
|
2571
|
+
if not MYPY:
|
|
2572
|
+
class DataSourcesSpecDataImportsArgsDict(TypedDict):
|
|
2573
|
+
"""
|
|
2574
|
+
Specifications of pull based data sources
|
|
2575
|
+
"""
|
|
2576
|
+
event_hub: NotRequired[pulumi.Input['DataImportSourcesEventHubArgsDict']]
|
|
2577
|
+
"""
|
|
2578
|
+
Definition of Event Hub configuration.
|
|
2579
|
+
"""
|
|
2580
|
+
elif False:
|
|
2581
|
+
DataSourcesSpecDataImportsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2582
|
+
|
|
2583
|
+
@pulumi.input_type
|
|
2584
|
+
class DataSourcesSpecDataImportsArgs:
|
|
2585
|
+
def __init__(__self__, *,
|
|
2586
|
+
event_hub: Optional[pulumi.Input['DataImportSourcesEventHubArgs']] = None):
|
|
2587
|
+
"""
|
|
2588
|
+
Specifications of pull based data sources
|
|
2589
|
+
:param pulumi.Input['DataImportSourcesEventHubArgs'] event_hub: Definition of Event Hub configuration.
|
|
2590
|
+
"""
|
|
2591
|
+
if event_hub is not None:
|
|
2592
|
+
pulumi.set(__self__, "event_hub", event_hub)
|
|
2593
|
+
|
|
2594
|
+
@property
|
|
2595
|
+
@pulumi.getter(name="eventHub")
|
|
2596
|
+
def event_hub(self) -> Optional[pulumi.Input['DataImportSourcesEventHubArgs']]:
|
|
2597
|
+
"""
|
|
2598
|
+
Definition of Event Hub configuration.
|
|
2599
|
+
"""
|
|
2600
|
+
return pulumi.get(self, "event_hub")
|
|
2601
|
+
|
|
2602
|
+
@event_hub.setter
|
|
2603
|
+
def event_hub(self, value: Optional[pulumi.Input['DataImportSourcesEventHubArgs']]):
|
|
2604
|
+
pulumi.set(self, "event_hub", value)
|
|
2605
|
+
|
|
2606
|
+
|
|
2607
|
+
if not MYPY:
|
|
2608
|
+
class DestinationsSpecAzureMonitorMetricsArgsDict(TypedDict):
|
|
2609
|
+
"""
|
|
2610
|
+
Azure Monitor Metrics destination.
|
|
2611
|
+
"""
|
|
2612
|
+
name: NotRequired[pulumi.Input[str]]
|
|
2613
|
+
"""
|
|
2614
|
+
A friendly name for the destination.
|
|
2615
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2616
|
+
"""
|
|
2617
|
+
elif False:
|
|
2618
|
+
DestinationsSpecAzureMonitorMetricsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2619
|
+
|
|
2620
|
+
@pulumi.input_type
|
|
2621
|
+
class DestinationsSpecAzureMonitorMetricsArgs:
|
|
2622
|
+
def __init__(__self__, *,
|
|
2623
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
2624
|
+
"""
|
|
2625
|
+
Azure Monitor Metrics destination.
|
|
2626
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
2627
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2628
|
+
"""
|
|
2629
|
+
if name is not None:
|
|
2630
|
+
pulumi.set(__self__, "name", name)
|
|
2631
|
+
|
|
2632
|
+
@property
|
|
2633
|
+
@pulumi.getter
|
|
2634
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2635
|
+
"""
|
|
2636
|
+
A friendly name for the destination.
|
|
2637
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2638
|
+
"""
|
|
2639
|
+
return pulumi.get(self, "name")
|
|
2640
|
+
|
|
2641
|
+
@name.setter
|
|
2642
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2643
|
+
pulumi.set(self, "name", value)
|
|
2644
|
+
|
|
2645
|
+
|
|
2646
|
+
if not MYPY:
|
|
2647
|
+
class DimensionArgsDict(TypedDict):
|
|
2648
|
+
"""
|
|
2649
|
+
Dimension splitting and filtering definition
|
|
2650
|
+
"""
|
|
2651
|
+
name: pulumi.Input[str]
|
|
2652
|
+
"""
|
|
2653
|
+
Name of the dimension
|
|
2654
|
+
"""
|
|
2655
|
+
operator: pulumi.Input[Union[str, 'DimensionOperator']]
|
|
2656
|
+
"""
|
|
2657
|
+
Operator for dimension values
|
|
2658
|
+
"""
|
|
2659
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
2660
|
+
"""
|
|
2661
|
+
List of dimension values
|
|
2662
|
+
"""
|
|
2663
|
+
elif False:
|
|
2664
|
+
DimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2665
|
+
|
|
2666
|
+
@pulumi.input_type
|
|
2667
|
+
class DimensionArgs:
|
|
2668
|
+
def __init__(__self__, *,
|
|
2669
|
+
name: pulumi.Input[str],
|
|
2670
|
+
operator: pulumi.Input[Union[str, 'DimensionOperator']],
|
|
2671
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2672
|
+
"""
|
|
2673
|
+
Dimension splitting and filtering definition
|
|
2674
|
+
:param pulumi.Input[str] name: Name of the dimension
|
|
2675
|
+
:param pulumi.Input[Union[str, 'DimensionOperator']] operator: Operator for dimension values
|
|
2676
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: List of dimension values
|
|
2677
|
+
"""
|
|
2678
|
+
pulumi.set(__self__, "name", name)
|
|
2679
|
+
pulumi.set(__self__, "operator", operator)
|
|
2680
|
+
pulumi.set(__self__, "values", values)
|
|
2681
|
+
|
|
2682
|
+
@property
|
|
2683
|
+
@pulumi.getter
|
|
2684
|
+
def name(self) -> pulumi.Input[str]:
|
|
2685
|
+
"""
|
|
2686
|
+
Name of the dimension
|
|
2687
|
+
"""
|
|
2688
|
+
return pulumi.get(self, "name")
|
|
2689
|
+
|
|
2690
|
+
@name.setter
|
|
2691
|
+
def name(self, value: pulumi.Input[str]):
|
|
2692
|
+
pulumi.set(self, "name", value)
|
|
2693
|
+
|
|
2694
|
+
@property
|
|
2695
|
+
@pulumi.getter
|
|
2696
|
+
def operator(self) -> pulumi.Input[Union[str, 'DimensionOperator']]:
|
|
2697
|
+
"""
|
|
2698
|
+
Operator for dimension values
|
|
2699
|
+
"""
|
|
2700
|
+
return pulumi.get(self, "operator")
|
|
2701
|
+
|
|
2702
|
+
@operator.setter
|
|
2703
|
+
def operator(self, value: pulumi.Input[Union[str, 'DimensionOperator']]):
|
|
2704
|
+
pulumi.set(self, "operator", value)
|
|
2705
|
+
|
|
2706
|
+
@property
|
|
2707
|
+
@pulumi.getter
|
|
2708
|
+
def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2709
|
+
"""
|
|
2710
|
+
List of dimension values
|
|
2711
|
+
"""
|
|
2712
|
+
return pulumi.get(self, "values")
|
|
2713
|
+
|
|
2714
|
+
@values.setter
|
|
2715
|
+
def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2716
|
+
pulumi.set(self, "values", value)
|
|
2717
|
+
|
|
2718
|
+
|
|
2719
|
+
if not MYPY:
|
|
2720
|
+
class EmailNotificationArgsDict(TypedDict):
|
|
2721
|
+
"""
|
|
2722
|
+
Email notification of an autoscale event.
|
|
2723
|
+
"""
|
|
2724
|
+
custom_emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2725
|
+
"""
|
|
2726
|
+
the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
2727
|
+
"""
|
|
2728
|
+
send_to_subscription_administrator: NotRequired[pulumi.Input[bool]]
|
|
2729
|
+
"""
|
|
2730
|
+
a value indicating whether to send email to subscription administrator.
|
|
2731
|
+
"""
|
|
2732
|
+
send_to_subscription_co_administrators: NotRequired[pulumi.Input[bool]]
|
|
2733
|
+
"""
|
|
2734
|
+
a value indicating whether to send email to subscription co-administrators.
|
|
2735
|
+
"""
|
|
2736
|
+
elif False:
|
|
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):
|
|
2745
|
+
"""
|
|
2746
|
+
Email notification of an autoscale event.
|
|
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.
|
|
2750
|
+
"""
|
|
2751
|
+
if custom_emails is not None:
|
|
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]]]]:
|
|
2765
|
+
"""
|
|
2766
|
+
the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
|
|
2767
|
+
"""
|
|
2768
|
+
return pulumi.get(self, "custom_emails")
|
|
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]]:
|
|
2777
|
+
"""
|
|
2778
|
+
a value indicating whether to send email to subscription administrator.
|
|
2779
|
+
"""
|
|
2780
|
+
return pulumi.get(self, "send_to_subscription_administrator")
|
|
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]]:
|
|
2789
|
+
"""
|
|
2790
|
+
a value indicating whether to send email to subscription co-administrators.
|
|
2791
|
+
"""
|
|
2792
|
+
return pulumi.get(self, "send_to_subscription_co_administrators")
|
|
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):
|
|
2801
|
+
"""
|
|
2802
|
+
An email receiver.
|
|
2803
|
+
"""
|
|
2804
|
+
email_address: pulumi.Input[str]
|
|
2805
|
+
"""
|
|
2806
|
+
The email address of this receiver.
|
|
2807
|
+
"""
|
|
2808
|
+
name: pulumi.Input[str]
|
|
2809
|
+
"""
|
|
2810
|
+
The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
2811
|
+
"""
|
|
2812
|
+
use_common_alert_schema: NotRequired[pulumi.Input[bool]]
|
|
2813
|
+
"""
|
|
2814
|
+
Indicates whether to use common alert schema.
|
|
2815
|
+
"""
|
|
2816
|
+
elif False:
|
|
2817
|
+
EmailReceiverArgsDict: TypeAlias = Mapping[str, Any]
|
|
2818
|
+
|
|
2819
|
+
@pulumi.input_type
|
|
2820
|
+
class EmailReceiverArgs:
|
|
2821
|
+
def __init__(__self__, *,
|
|
2822
|
+
email_address: pulumi.Input[str],
|
|
2823
|
+
name: pulumi.Input[str],
|
|
2824
|
+
use_common_alert_schema: Optional[pulumi.Input[bool]] = None):
|
|
2825
|
+
"""
|
|
2826
|
+
An email receiver.
|
|
2827
|
+
:param pulumi.Input[str] email_address: The email address of this receiver.
|
|
2828
|
+
:param pulumi.Input[str] name: The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
2829
|
+
:param pulumi.Input[bool] use_common_alert_schema: Indicates whether to use common alert schema.
|
|
2830
|
+
"""
|
|
2831
|
+
pulumi.set(__self__, "email_address", email_address)
|
|
2832
|
+
pulumi.set(__self__, "name", name)
|
|
2833
|
+
if use_common_alert_schema is None:
|
|
2834
|
+
use_common_alert_schema = False
|
|
2835
|
+
if use_common_alert_schema is not None:
|
|
2836
|
+
pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
|
|
2837
|
+
|
|
2838
|
+
@property
|
|
2839
|
+
@pulumi.getter(name="emailAddress")
|
|
2840
|
+
def email_address(self) -> pulumi.Input[str]:
|
|
2841
|
+
"""
|
|
2842
|
+
The email address of this receiver.
|
|
2843
|
+
"""
|
|
2844
|
+
return pulumi.get(self, "email_address")
|
|
2845
|
+
|
|
2846
|
+
@email_address.setter
|
|
2847
|
+
def email_address(self, value: pulumi.Input[str]):
|
|
2848
|
+
pulumi.set(self, "email_address", value)
|
|
2849
|
+
|
|
2850
|
+
@property
|
|
2851
|
+
@pulumi.getter
|
|
2852
|
+
def name(self) -> pulumi.Input[str]:
|
|
2853
|
+
"""
|
|
2854
|
+
The name of the email receiver. Names must be unique across all receivers within a tenant action group.
|
|
2855
|
+
"""
|
|
2856
|
+
return pulumi.get(self, "name")
|
|
2857
|
+
|
|
2858
|
+
@name.setter
|
|
2859
|
+
def name(self, value: pulumi.Input[str]):
|
|
2860
|
+
pulumi.set(self, "name", value)
|
|
2861
|
+
|
|
2862
|
+
@property
|
|
2863
|
+
@pulumi.getter(name="useCommonAlertSchema")
|
|
2864
|
+
def use_common_alert_schema(self) -> Optional[pulumi.Input[bool]]:
|
|
2865
|
+
"""
|
|
2866
|
+
Indicates whether to use common alert schema.
|
|
2867
|
+
"""
|
|
2868
|
+
return pulumi.get(self, "use_common_alert_schema")
|
|
2869
|
+
|
|
2870
|
+
@use_common_alert_schema.setter
|
|
2871
|
+
def use_common_alert_schema(self, value: Optional[pulumi.Input[bool]]):
|
|
2872
|
+
pulumi.set(self, "use_common_alert_schema", value)
|
|
2873
|
+
|
|
2874
|
+
|
|
2875
|
+
if not MYPY:
|
|
2876
|
+
class EventHubDestinationArgsDict(TypedDict):
|
|
2877
|
+
event_hub_resource_id: NotRequired[pulumi.Input[str]]
|
|
2878
|
+
"""
|
|
2879
|
+
The resource ID of the event hub.
|
|
2880
|
+
"""
|
|
2881
|
+
name: NotRequired[pulumi.Input[str]]
|
|
2882
|
+
"""
|
|
2883
|
+
A friendly name for the destination.
|
|
2884
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2885
|
+
"""
|
|
2886
|
+
elif False:
|
|
2887
|
+
EventHubDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2888
|
+
|
|
2889
|
+
@pulumi.input_type
|
|
2890
|
+
class EventHubDestinationArgs:
|
|
2891
|
+
def __init__(__self__, *,
|
|
2892
|
+
event_hub_resource_id: Optional[pulumi.Input[str]] = None,
|
|
2893
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
2894
|
+
"""
|
|
2895
|
+
:param pulumi.Input[str] event_hub_resource_id: The resource ID of the event hub.
|
|
2896
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
2897
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2898
|
+
"""
|
|
2899
|
+
if event_hub_resource_id is not None:
|
|
2900
|
+
pulumi.set(__self__, "event_hub_resource_id", event_hub_resource_id)
|
|
2901
|
+
if name is not None:
|
|
2902
|
+
pulumi.set(__self__, "name", name)
|
|
2903
|
+
|
|
2904
|
+
@property
|
|
2905
|
+
@pulumi.getter(name="eventHubResourceId")
|
|
2906
|
+
def event_hub_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
2907
|
+
"""
|
|
2908
|
+
The resource ID of the event hub.
|
|
2909
|
+
"""
|
|
2910
|
+
return pulumi.get(self, "event_hub_resource_id")
|
|
2911
|
+
|
|
2912
|
+
@event_hub_resource_id.setter
|
|
2913
|
+
def event_hub_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
2914
|
+
pulumi.set(self, "event_hub_resource_id", value)
|
|
2915
|
+
|
|
2916
|
+
@property
|
|
2917
|
+
@pulumi.getter
|
|
2918
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2919
|
+
"""
|
|
2920
|
+
A friendly name for the destination.
|
|
2921
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2922
|
+
"""
|
|
2923
|
+
return pulumi.get(self, "name")
|
|
2924
|
+
|
|
2925
|
+
@name.setter
|
|
2926
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2927
|
+
pulumi.set(self, "name", value)
|
|
2928
|
+
|
|
2929
|
+
|
|
2930
|
+
if not MYPY:
|
|
2931
|
+
class EventHubDirectDestinationArgsDict(TypedDict):
|
|
2932
|
+
event_hub_resource_id: NotRequired[pulumi.Input[str]]
|
|
2933
|
+
"""
|
|
2934
|
+
The resource ID of the event hub.
|
|
2935
|
+
"""
|
|
2936
|
+
name: NotRequired[pulumi.Input[str]]
|
|
2937
|
+
"""
|
|
2938
|
+
A friendly name for the destination.
|
|
2939
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2940
|
+
"""
|
|
2941
|
+
elif False:
|
|
2942
|
+
EventHubDirectDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2943
|
+
|
|
2944
|
+
@pulumi.input_type
|
|
2945
|
+
class EventHubDirectDestinationArgs:
|
|
2946
|
+
def __init__(__self__, *,
|
|
2947
|
+
event_hub_resource_id: Optional[pulumi.Input[str]] = None,
|
|
2948
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
2949
|
+
"""
|
|
2950
|
+
:param pulumi.Input[str] event_hub_resource_id: The resource ID of the event hub.
|
|
2951
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
2952
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2953
|
+
"""
|
|
2954
|
+
if event_hub_resource_id is not None:
|
|
2955
|
+
pulumi.set(__self__, "event_hub_resource_id", event_hub_resource_id)
|
|
2956
|
+
if name is not None:
|
|
2957
|
+
pulumi.set(__self__, "name", name)
|
|
2958
|
+
|
|
2959
|
+
@property
|
|
2960
|
+
@pulumi.getter(name="eventHubResourceId")
|
|
2961
|
+
def event_hub_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
2962
|
+
"""
|
|
2963
|
+
The resource ID of the event hub.
|
|
2964
|
+
"""
|
|
2965
|
+
return pulumi.get(self, "event_hub_resource_id")
|
|
2966
|
+
|
|
2967
|
+
@event_hub_resource_id.setter
|
|
2968
|
+
def event_hub_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
2969
|
+
pulumi.set(self, "event_hub_resource_id", value)
|
|
2970
|
+
|
|
2971
|
+
@property
|
|
2972
|
+
@pulumi.getter
|
|
2973
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2974
|
+
"""
|
|
2975
|
+
A friendly name for the destination.
|
|
2976
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
2977
|
+
"""
|
|
2978
|
+
return pulumi.get(self, "name")
|
|
2979
|
+
|
|
2980
|
+
@name.setter
|
|
2981
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2982
|
+
pulumi.set(self, "name", value)
|
|
2983
|
+
|
|
2984
|
+
|
|
2985
|
+
if not MYPY:
|
|
2986
|
+
class EventHubReceiverArgsDict(TypedDict):
|
|
2987
|
+
"""
|
|
2988
|
+
An Event hub receiver.
|
|
1957
2989
|
"""
|
|
1958
2990
|
event_hub_name: pulumi.Input[str]
|
|
1959
2991
|
"""
|
|
@@ -2136,66 +3168,189 @@ class ExporterArgs:
|
|
|
2136
3168
|
azure_monitor_workspace_logs: Optional[pulumi.Input['AzureMonitorWorkspaceLogsExporterArgs']] = None,
|
|
2137
3169
|
tcp: Optional[pulumi.Input['TcpExporterArgs']] = None):
|
|
2138
3170
|
"""
|
|
2139
|
-
Exporter Info.
|
|
2140
|
-
:param pulumi.Input[str] name: The name of exporter.
|
|
2141
|
-
:param pulumi.Input[Union[str, 'ExporterType']] type: The type of exporter.
|
|
2142
|
-
:param pulumi.Input['AzureMonitorWorkspaceLogsExporterArgs'] azure_monitor_workspace_logs: Azure Monitor Workspace Logs specific configurations.
|
|
2143
|
-
:param pulumi.Input['TcpExporterArgs'] tcp: TCP based exporter. Used for pipelineGroup exporter.
|
|
3171
|
+
Exporter Info.
|
|
3172
|
+
:param pulumi.Input[str] name: The name of exporter.
|
|
3173
|
+
:param pulumi.Input[Union[str, 'ExporterType']] type: The type of exporter.
|
|
3174
|
+
:param pulumi.Input['AzureMonitorWorkspaceLogsExporterArgs'] azure_monitor_workspace_logs: Azure Monitor Workspace Logs specific configurations.
|
|
3175
|
+
:param pulumi.Input['TcpExporterArgs'] tcp: TCP based exporter. Used for pipelineGroup exporter.
|
|
3176
|
+
"""
|
|
3177
|
+
pulumi.set(__self__, "name", name)
|
|
3178
|
+
pulumi.set(__self__, "type", type)
|
|
3179
|
+
if azure_monitor_workspace_logs is not None:
|
|
3180
|
+
pulumi.set(__self__, "azure_monitor_workspace_logs", azure_monitor_workspace_logs)
|
|
3181
|
+
if tcp is not None:
|
|
3182
|
+
pulumi.set(__self__, "tcp", tcp)
|
|
3183
|
+
|
|
3184
|
+
@property
|
|
3185
|
+
@pulumi.getter
|
|
3186
|
+
def name(self) -> pulumi.Input[str]:
|
|
3187
|
+
"""
|
|
3188
|
+
The name of exporter.
|
|
3189
|
+
"""
|
|
3190
|
+
return pulumi.get(self, "name")
|
|
3191
|
+
|
|
3192
|
+
@name.setter
|
|
3193
|
+
def name(self, value: pulumi.Input[str]):
|
|
3194
|
+
pulumi.set(self, "name", value)
|
|
3195
|
+
|
|
3196
|
+
@property
|
|
3197
|
+
@pulumi.getter
|
|
3198
|
+
def type(self) -> pulumi.Input[Union[str, 'ExporterType']]:
|
|
3199
|
+
"""
|
|
3200
|
+
The type of exporter.
|
|
3201
|
+
"""
|
|
3202
|
+
return pulumi.get(self, "type")
|
|
3203
|
+
|
|
3204
|
+
@type.setter
|
|
3205
|
+
def type(self, value: pulumi.Input[Union[str, 'ExporterType']]):
|
|
3206
|
+
pulumi.set(self, "type", value)
|
|
3207
|
+
|
|
3208
|
+
@property
|
|
3209
|
+
@pulumi.getter(name="azureMonitorWorkspaceLogs")
|
|
3210
|
+
def azure_monitor_workspace_logs(self) -> Optional[pulumi.Input['AzureMonitorWorkspaceLogsExporterArgs']]:
|
|
3211
|
+
"""
|
|
3212
|
+
Azure Monitor Workspace Logs specific configurations.
|
|
3213
|
+
"""
|
|
3214
|
+
return pulumi.get(self, "azure_monitor_workspace_logs")
|
|
3215
|
+
|
|
3216
|
+
@azure_monitor_workspace_logs.setter
|
|
3217
|
+
def azure_monitor_workspace_logs(self, value: Optional[pulumi.Input['AzureMonitorWorkspaceLogsExporterArgs']]):
|
|
3218
|
+
pulumi.set(self, "azure_monitor_workspace_logs", value)
|
|
3219
|
+
|
|
3220
|
+
@property
|
|
3221
|
+
@pulumi.getter
|
|
3222
|
+
def tcp(self) -> Optional[pulumi.Input['TcpExporterArgs']]:
|
|
3223
|
+
"""
|
|
3224
|
+
TCP based exporter. Used for pipelineGroup exporter.
|
|
3225
|
+
"""
|
|
3226
|
+
return pulumi.get(self, "tcp")
|
|
3227
|
+
|
|
3228
|
+
@tcp.setter
|
|
3229
|
+
def tcp(self, value: Optional[pulumi.Input['TcpExporterArgs']]):
|
|
3230
|
+
pulumi.set(self, "tcp", value)
|
|
3231
|
+
|
|
3232
|
+
|
|
3233
|
+
if not MYPY:
|
|
3234
|
+
class ExtensionDataSourceArgsDict(TypedDict):
|
|
3235
|
+
"""
|
|
3236
|
+
Definition of which data will be collected from a separate VM extension that integrates with the Azure Monitor Agent.
|
|
3237
|
+
Collected from either Windows and Linux machines, depending on which extension is defined.
|
|
3238
|
+
"""
|
|
3239
|
+
extension_name: pulumi.Input[str]
|
|
3240
|
+
"""
|
|
3241
|
+
The name of the VM extension.
|
|
3242
|
+
"""
|
|
3243
|
+
extension_settings: NotRequired[Any]
|
|
3244
|
+
"""
|
|
3245
|
+
The extension settings. The format is specific for particular extension.
|
|
3246
|
+
"""
|
|
3247
|
+
input_data_sources: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3248
|
+
"""
|
|
3249
|
+
The list of data sources this extension needs data from.
|
|
3250
|
+
"""
|
|
3251
|
+
name: NotRequired[pulumi.Input[str]]
|
|
3252
|
+
"""
|
|
3253
|
+
A friendly name for the data source.
|
|
3254
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
3255
|
+
"""
|
|
3256
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownExtensionDataSourceStreams']]]]]
|
|
3257
|
+
"""
|
|
3258
|
+
List of streams that this data source will be sent to.
|
|
3259
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
3260
|
+
"""
|
|
3261
|
+
elif False:
|
|
3262
|
+
ExtensionDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
3263
|
+
|
|
3264
|
+
@pulumi.input_type
|
|
3265
|
+
class ExtensionDataSourceArgs:
|
|
3266
|
+
def __init__(__self__, *,
|
|
3267
|
+
extension_name: pulumi.Input[str],
|
|
3268
|
+
extension_settings: Optional[Any] = None,
|
|
3269
|
+
input_data_sources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3270
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
3271
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownExtensionDataSourceStreams']]]]] = None):
|
|
3272
|
+
"""
|
|
3273
|
+
Definition of which data will be collected from a separate VM extension that integrates with the Azure Monitor Agent.
|
|
3274
|
+
Collected from either Windows and Linux machines, depending on which extension is defined.
|
|
3275
|
+
:param pulumi.Input[str] extension_name: The name of the VM extension.
|
|
3276
|
+
:param Any extension_settings: The extension settings. The format is specific for particular extension.
|
|
3277
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] input_data_sources: The list of data sources this extension needs data from.
|
|
3278
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
3279
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
3280
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownExtensionDataSourceStreams']]]] streams: List of streams that this data source will be sent to.
|
|
3281
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
3282
|
+
"""
|
|
3283
|
+
pulumi.set(__self__, "extension_name", extension_name)
|
|
3284
|
+
if extension_settings is not None:
|
|
3285
|
+
pulumi.set(__self__, "extension_settings", extension_settings)
|
|
3286
|
+
if input_data_sources is not None:
|
|
3287
|
+
pulumi.set(__self__, "input_data_sources", input_data_sources)
|
|
3288
|
+
if name is not None:
|
|
3289
|
+
pulumi.set(__self__, "name", name)
|
|
3290
|
+
if streams is not None:
|
|
3291
|
+
pulumi.set(__self__, "streams", streams)
|
|
3292
|
+
|
|
3293
|
+
@property
|
|
3294
|
+
@pulumi.getter(name="extensionName")
|
|
3295
|
+
def extension_name(self) -> pulumi.Input[str]:
|
|
3296
|
+
"""
|
|
3297
|
+
The name of the VM extension.
|
|
2144
3298
|
"""
|
|
2145
|
-
pulumi.
|
|
2146
|
-
|
|
2147
|
-
|
|
2148
|
-
|
|
2149
|
-
|
|
2150
|
-
pulumi.set(__self__, "tcp", tcp)
|
|
3299
|
+
return pulumi.get(self, "extension_name")
|
|
3300
|
+
|
|
3301
|
+
@extension_name.setter
|
|
3302
|
+
def extension_name(self, value: pulumi.Input[str]):
|
|
3303
|
+
pulumi.set(self, "extension_name", value)
|
|
2151
3304
|
|
|
2152
3305
|
@property
|
|
2153
|
-
@pulumi.getter
|
|
2154
|
-
def
|
|
3306
|
+
@pulumi.getter(name="extensionSettings")
|
|
3307
|
+
def extension_settings(self) -> Optional[Any]:
|
|
2155
3308
|
"""
|
|
2156
|
-
The
|
|
3309
|
+
The extension settings. The format is specific for particular extension.
|
|
2157
3310
|
"""
|
|
2158
|
-
return pulumi.get(self, "
|
|
3311
|
+
return pulumi.get(self, "extension_settings")
|
|
2159
3312
|
|
|
2160
|
-
@
|
|
2161
|
-
def
|
|
2162
|
-
pulumi.set(self, "
|
|
3313
|
+
@extension_settings.setter
|
|
3314
|
+
def extension_settings(self, value: Optional[Any]):
|
|
3315
|
+
pulumi.set(self, "extension_settings", value)
|
|
2163
3316
|
|
|
2164
3317
|
@property
|
|
2165
|
-
@pulumi.getter
|
|
2166
|
-
def
|
|
3318
|
+
@pulumi.getter(name="inputDataSources")
|
|
3319
|
+
def input_data_sources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2167
3320
|
"""
|
|
2168
|
-
The
|
|
3321
|
+
The list of data sources this extension needs data from.
|
|
2169
3322
|
"""
|
|
2170
|
-
return pulumi.get(self, "
|
|
3323
|
+
return pulumi.get(self, "input_data_sources")
|
|
2171
3324
|
|
|
2172
|
-
@
|
|
2173
|
-
def
|
|
2174
|
-
pulumi.set(self, "
|
|
3325
|
+
@input_data_sources.setter
|
|
3326
|
+
def input_data_sources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3327
|
+
pulumi.set(self, "input_data_sources", value)
|
|
2175
3328
|
|
|
2176
3329
|
@property
|
|
2177
|
-
@pulumi.getter
|
|
2178
|
-
def
|
|
3330
|
+
@pulumi.getter
|
|
3331
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2179
3332
|
"""
|
|
2180
|
-
|
|
3333
|
+
A friendly name for the data source.
|
|
3334
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
2181
3335
|
"""
|
|
2182
|
-
return pulumi.get(self, "
|
|
3336
|
+
return pulumi.get(self, "name")
|
|
2183
3337
|
|
|
2184
|
-
@
|
|
2185
|
-
def
|
|
2186
|
-
pulumi.set(self, "
|
|
3338
|
+
@name.setter
|
|
3339
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
3340
|
+
pulumi.set(self, "name", value)
|
|
2187
3341
|
|
|
2188
3342
|
@property
|
|
2189
3343
|
@pulumi.getter
|
|
2190
|
-
def
|
|
3344
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownExtensionDataSourceStreams']]]]]:
|
|
2191
3345
|
"""
|
|
2192
|
-
|
|
3346
|
+
List of streams that this data source will be sent to.
|
|
3347
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
2193
3348
|
"""
|
|
2194
|
-
return pulumi.get(self, "
|
|
3349
|
+
return pulumi.get(self, "streams")
|
|
2195
3350
|
|
|
2196
|
-
@
|
|
2197
|
-
def
|
|
2198
|
-
pulumi.set(self, "
|
|
3351
|
+
@streams.setter
|
|
3352
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownExtensionDataSourceStreams']]]]]):
|
|
3353
|
+
pulumi.set(self, "streams", value)
|
|
2199
3354
|
|
|
2200
3355
|
|
|
2201
3356
|
if not MYPY:
|
|
@@ -2253,6 +3408,84 @@ class IdentityArgs:
|
|
|
2253
3408
|
pulumi.set(self, "user_assigned_identities", value)
|
|
2254
3409
|
|
|
2255
3410
|
|
|
3411
|
+
if not MYPY:
|
|
3412
|
+
class IisLogsDataSourceArgsDict(TypedDict):
|
|
3413
|
+
"""
|
|
3414
|
+
Enables IIS logs to be collected by this data collection rule.
|
|
3415
|
+
"""
|
|
3416
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
3417
|
+
"""
|
|
3418
|
+
IIS streams
|
|
3419
|
+
"""
|
|
3420
|
+
log_directories: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3421
|
+
"""
|
|
3422
|
+
Absolute paths file location
|
|
3423
|
+
"""
|
|
3424
|
+
name: NotRequired[pulumi.Input[str]]
|
|
3425
|
+
"""
|
|
3426
|
+
A friendly name for the data source.
|
|
3427
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
3428
|
+
"""
|
|
3429
|
+
elif False:
|
|
3430
|
+
IisLogsDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
3431
|
+
|
|
3432
|
+
@pulumi.input_type
|
|
3433
|
+
class IisLogsDataSourceArgs:
|
|
3434
|
+
def __init__(__self__, *,
|
|
3435
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
3436
|
+
log_directories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3437
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
3438
|
+
"""
|
|
3439
|
+
Enables IIS logs to be collected by this data collection rule.
|
|
3440
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] streams: IIS streams
|
|
3441
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] log_directories: Absolute paths file location
|
|
3442
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
3443
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
3444
|
+
"""
|
|
3445
|
+
pulumi.set(__self__, "streams", streams)
|
|
3446
|
+
if log_directories is not None:
|
|
3447
|
+
pulumi.set(__self__, "log_directories", log_directories)
|
|
3448
|
+
if name is not None:
|
|
3449
|
+
pulumi.set(__self__, "name", name)
|
|
3450
|
+
|
|
3451
|
+
@property
|
|
3452
|
+
@pulumi.getter
|
|
3453
|
+
def streams(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
3454
|
+
"""
|
|
3455
|
+
IIS streams
|
|
3456
|
+
"""
|
|
3457
|
+
return pulumi.get(self, "streams")
|
|
3458
|
+
|
|
3459
|
+
@streams.setter
|
|
3460
|
+
def streams(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
3461
|
+
pulumi.set(self, "streams", value)
|
|
3462
|
+
|
|
3463
|
+
@property
|
|
3464
|
+
@pulumi.getter(name="logDirectories")
|
|
3465
|
+
def log_directories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3466
|
+
"""
|
|
3467
|
+
Absolute paths file location
|
|
3468
|
+
"""
|
|
3469
|
+
return pulumi.get(self, "log_directories")
|
|
3470
|
+
|
|
3471
|
+
@log_directories.setter
|
|
3472
|
+
def log_directories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3473
|
+
pulumi.set(self, "log_directories", value)
|
|
3474
|
+
|
|
3475
|
+
@property
|
|
3476
|
+
@pulumi.getter
|
|
3477
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3478
|
+
"""
|
|
3479
|
+
A friendly name for the data source.
|
|
3480
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
3481
|
+
"""
|
|
3482
|
+
return pulumi.get(self, "name")
|
|
3483
|
+
|
|
3484
|
+
@name.setter
|
|
3485
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
3486
|
+
pulumi.set(self, "name", value)
|
|
3487
|
+
|
|
3488
|
+
|
|
2256
3489
|
if not MYPY:
|
|
2257
3490
|
class IncidentReceiverArgsDict(TypedDict):
|
|
2258
3491
|
"""
|
|
@@ -2573,110 +3806,359 @@ class JsonArrayMapperArgs:
|
|
|
2573
3806
|
pulumi.set(self, "destination_field", value)
|
|
2574
3807
|
|
|
2575
3808
|
@property
|
|
2576
|
-
@pulumi.getter(name="sourceField")
|
|
2577
|
-
def source_field(self) -> Optional[pulumi.Input['JsonMapperSourceFieldArgs']]:
|
|
3809
|
+
@pulumi.getter(name="sourceField")
|
|
3810
|
+
def source_field(self) -> Optional[pulumi.Input['JsonMapperSourceFieldArgs']]:
|
|
3811
|
+
"""
|
|
3812
|
+
Define a source field from which a json array will be read and parsed to it's elements. The number of elements in the json array is expected to be the same as the length of keys.
|
|
3813
|
+
"""
|
|
3814
|
+
return pulumi.get(self, "source_field")
|
|
3815
|
+
|
|
3816
|
+
@source_field.setter
|
|
3817
|
+
def source_field(self, value: Optional[pulumi.Input['JsonMapperSourceFieldArgs']]):
|
|
3818
|
+
pulumi.set(self, "source_field", value)
|
|
3819
|
+
|
|
3820
|
+
|
|
3821
|
+
if not MYPY:
|
|
3822
|
+
class JsonMapperDestinationFieldArgsDict(TypedDict):
|
|
3823
|
+
"""
|
|
3824
|
+
JsonArrayMapper destination field used to describe the field to which the parsed output will be written.
|
|
3825
|
+
"""
|
|
3826
|
+
destination: NotRequired[pulumi.Input[Union[str, 'JsonMapperElement']]]
|
|
3827
|
+
"""
|
|
3828
|
+
Define the destination's element. The element is the body or the attributes of the message, to which the json array mapper will write the output map.
|
|
3829
|
+
"""
|
|
3830
|
+
field_name: NotRequired[pulumi.Input[str]]
|
|
3831
|
+
"""
|
|
3832
|
+
Define a destination field name under the given element. Leaving this empty, means the root of the element. In case element=attributes and fieldName is empty, the object's attributes themselves will contain the key value output pairs.
|
|
3833
|
+
"""
|
|
3834
|
+
elif False:
|
|
3835
|
+
JsonMapperDestinationFieldArgsDict: TypeAlias = Mapping[str, Any]
|
|
3836
|
+
|
|
3837
|
+
@pulumi.input_type
|
|
3838
|
+
class JsonMapperDestinationFieldArgs:
|
|
3839
|
+
def __init__(__self__, *,
|
|
3840
|
+
destination: Optional[pulumi.Input[Union[str, 'JsonMapperElement']]] = None,
|
|
3841
|
+
field_name: Optional[pulumi.Input[str]] = None):
|
|
3842
|
+
"""
|
|
3843
|
+
JsonArrayMapper destination field used to describe the field to which the parsed output will be written.
|
|
3844
|
+
:param pulumi.Input[Union[str, 'JsonMapperElement']] destination: Define the destination's element. The element is the body or the attributes of the message, to which the json array mapper will write the output map.
|
|
3845
|
+
:param pulumi.Input[str] field_name: Define a destination field name under the given element. Leaving this empty, means the root of the element. In case element=attributes and fieldName is empty, the object's attributes themselves will contain the key value output pairs.
|
|
3846
|
+
"""
|
|
3847
|
+
if destination is None:
|
|
3848
|
+
destination = 'attributes'
|
|
3849
|
+
if destination is not None:
|
|
3850
|
+
pulumi.set(__self__, "destination", destination)
|
|
3851
|
+
if field_name is not None:
|
|
3852
|
+
pulumi.set(__self__, "field_name", field_name)
|
|
3853
|
+
|
|
3854
|
+
@property
|
|
3855
|
+
@pulumi.getter
|
|
3856
|
+
def destination(self) -> Optional[pulumi.Input[Union[str, 'JsonMapperElement']]]:
|
|
3857
|
+
"""
|
|
3858
|
+
Define the destination's element. The element is the body or the attributes of the message, to which the json array mapper will write the output map.
|
|
3859
|
+
"""
|
|
3860
|
+
return pulumi.get(self, "destination")
|
|
3861
|
+
|
|
3862
|
+
@destination.setter
|
|
3863
|
+
def destination(self, value: Optional[pulumi.Input[Union[str, 'JsonMapperElement']]]):
|
|
3864
|
+
pulumi.set(self, "destination", value)
|
|
3865
|
+
|
|
3866
|
+
@property
|
|
3867
|
+
@pulumi.getter(name="fieldName")
|
|
3868
|
+
def field_name(self) -> Optional[pulumi.Input[str]]:
|
|
3869
|
+
"""
|
|
3870
|
+
Define a destination field name under the given element. Leaving this empty, means the root of the element. In case element=attributes and fieldName is empty, the object's attributes themselves will contain the key value output pairs.
|
|
3871
|
+
"""
|
|
3872
|
+
return pulumi.get(self, "field_name")
|
|
3873
|
+
|
|
3874
|
+
@field_name.setter
|
|
3875
|
+
def field_name(self, value: Optional[pulumi.Input[str]]):
|
|
3876
|
+
pulumi.set(self, "field_name", value)
|
|
3877
|
+
|
|
3878
|
+
|
|
3879
|
+
if not MYPY:
|
|
3880
|
+
class JsonMapperSourceFieldArgsDict(TypedDict):
|
|
3881
|
+
"""
|
|
3882
|
+
JsonArrayMapper source field used to describe the field from which the json array will be read.
|
|
3883
|
+
"""
|
|
3884
|
+
field_name: NotRequired[pulumi.Input[str]]
|
|
3885
|
+
"""
|
|
3886
|
+
Define a source field name from which the json array mapper will read the json array. Leaving this empty, means reading the body of the message itself.
|
|
3887
|
+
"""
|
|
3888
|
+
elif False:
|
|
3889
|
+
JsonMapperSourceFieldArgsDict: TypeAlias = Mapping[str, Any]
|
|
3890
|
+
|
|
3891
|
+
@pulumi.input_type
|
|
3892
|
+
class JsonMapperSourceFieldArgs:
|
|
3893
|
+
def __init__(__self__, *,
|
|
3894
|
+
field_name: Optional[pulumi.Input[str]] = None):
|
|
3895
|
+
"""
|
|
3896
|
+
JsonArrayMapper source field used to describe the field from which the json array will be read.
|
|
3897
|
+
:param pulumi.Input[str] field_name: Define a source field name from which the json array mapper will read the json array. Leaving this empty, means reading the body of the message itself.
|
|
3898
|
+
"""
|
|
3899
|
+
if field_name is not None:
|
|
3900
|
+
pulumi.set(__self__, "field_name", field_name)
|
|
3901
|
+
|
|
3902
|
+
@property
|
|
3903
|
+
@pulumi.getter(name="fieldName")
|
|
3904
|
+
def field_name(self) -> Optional[pulumi.Input[str]]:
|
|
3905
|
+
"""
|
|
3906
|
+
Define a source field name from which the json array mapper will read the json array. Leaving this empty, means reading the body of the message itself.
|
|
3907
|
+
"""
|
|
3908
|
+
return pulumi.get(self, "field_name")
|
|
3909
|
+
|
|
3910
|
+
@field_name.setter
|
|
3911
|
+
def field_name(self, value: Optional[pulumi.Input[str]]):
|
|
3912
|
+
pulumi.set(self, "field_name", value)
|
|
3913
|
+
|
|
3914
|
+
|
|
3915
|
+
if not MYPY:
|
|
3916
|
+
class LogAnalyticsDestinationArgsDict(TypedDict):
|
|
3917
|
+
"""
|
|
3918
|
+
Log Analytics destination.
|
|
3919
|
+
"""
|
|
3920
|
+
name: NotRequired[pulumi.Input[str]]
|
|
3921
|
+
"""
|
|
3922
|
+
A friendly name for the destination.
|
|
3923
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
3924
|
+
"""
|
|
3925
|
+
workspace_resource_id: NotRequired[pulumi.Input[str]]
|
|
3926
|
+
"""
|
|
3927
|
+
The resource ID of the Log Analytics workspace.
|
|
3928
|
+
"""
|
|
3929
|
+
elif False:
|
|
3930
|
+
LogAnalyticsDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3931
|
+
|
|
3932
|
+
@pulumi.input_type
|
|
3933
|
+
class LogAnalyticsDestinationArgs:
|
|
3934
|
+
def __init__(__self__, *,
|
|
3935
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
3936
|
+
workspace_resource_id: Optional[pulumi.Input[str]] = None):
|
|
3937
|
+
"""
|
|
3938
|
+
Log Analytics destination.
|
|
3939
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
3940
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
3941
|
+
:param pulumi.Input[str] workspace_resource_id: The resource ID of the Log Analytics workspace.
|
|
3942
|
+
"""
|
|
3943
|
+
if name is not None:
|
|
3944
|
+
pulumi.set(__self__, "name", name)
|
|
3945
|
+
if workspace_resource_id is not None:
|
|
3946
|
+
pulumi.set(__self__, "workspace_resource_id", workspace_resource_id)
|
|
3947
|
+
|
|
3948
|
+
@property
|
|
3949
|
+
@pulumi.getter
|
|
3950
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3951
|
+
"""
|
|
3952
|
+
A friendly name for the destination.
|
|
3953
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
3954
|
+
"""
|
|
3955
|
+
return pulumi.get(self, "name")
|
|
3956
|
+
|
|
3957
|
+
@name.setter
|
|
3958
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
3959
|
+
pulumi.set(self, "name", value)
|
|
3960
|
+
|
|
3961
|
+
@property
|
|
3962
|
+
@pulumi.getter(name="workspaceResourceId")
|
|
3963
|
+
def workspace_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
3964
|
+
"""
|
|
3965
|
+
The resource ID of the Log Analytics workspace.
|
|
3966
|
+
"""
|
|
3967
|
+
return pulumi.get(self, "workspace_resource_id")
|
|
3968
|
+
|
|
3969
|
+
@workspace_resource_id.setter
|
|
3970
|
+
def workspace_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
3971
|
+
pulumi.set(self, "workspace_resource_id", value)
|
|
3972
|
+
|
|
3973
|
+
|
|
3974
|
+
if not MYPY:
|
|
3975
|
+
class LogFileSettingsTextArgsDict(TypedDict):
|
|
3976
|
+
"""
|
|
3977
|
+
Text settings
|
|
3978
|
+
"""
|
|
3979
|
+
record_start_timestamp_format: pulumi.Input[Union[str, 'KnownLogFileTextSettingsRecordStartTimestampFormat']]
|
|
3980
|
+
"""
|
|
3981
|
+
One of the supported timestamp formats
|
|
3982
|
+
"""
|
|
3983
|
+
elif False:
|
|
3984
|
+
LogFileSettingsTextArgsDict: TypeAlias = Mapping[str, Any]
|
|
3985
|
+
|
|
3986
|
+
@pulumi.input_type
|
|
3987
|
+
class LogFileSettingsTextArgs:
|
|
3988
|
+
def __init__(__self__, *,
|
|
3989
|
+
record_start_timestamp_format: pulumi.Input[Union[str, 'KnownLogFileTextSettingsRecordStartTimestampFormat']]):
|
|
3990
|
+
"""
|
|
3991
|
+
Text settings
|
|
3992
|
+
:param pulumi.Input[Union[str, 'KnownLogFileTextSettingsRecordStartTimestampFormat']] record_start_timestamp_format: One of the supported timestamp formats
|
|
3993
|
+
"""
|
|
3994
|
+
pulumi.set(__self__, "record_start_timestamp_format", record_start_timestamp_format)
|
|
3995
|
+
|
|
3996
|
+
@property
|
|
3997
|
+
@pulumi.getter(name="recordStartTimestampFormat")
|
|
3998
|
+
def record_start_timestamp_format(self) -> pulumi.Input[Union[str, 'KnownLogFileTextSettingsRecordStartTimestampFormat']]:
|
|
3999
|
+
"""
|
|
4000
|
+
One of the supported timestamp formats
|
|
4001
|
+
"""
|
|
4002
|
+
return pulumi.get(self, "record_start_timestamp_format")
|
|
4003
|
+
|
|
4004
|
+
@record_start_timestamp_format.setter
|
|
4005
|
+
def record_start_timestamp_format(self, value: pulumi.Input[Union[str, 'KnownLogFileTextSettingsRecordStartTimestampFormat']]):
|
|
4006
|
+
pulumi.set(self, "record_start_timestamp_format", value)
|
|
4007
|
+
|
|
4008
|
+
|
|
4009
|
+
if not MYPY:
|
|
4010
|
+
class LogFilesDataSourceSettingsArgsDict(TypedDict):
|
|
4011
|
+
"""
|
|
4012
|
+
The log files specific settings.
|
|
4013
|
+
"""
|
|
4014
|
+
text: NotRequired[pulumi.Input['LogFileSettingsTextArgsDict']]
|
|
4015
|
+
"""
|
|
4016
|
+
Text settings
|
|
4017
|
+
"""
|
|
4018
|
+
elif False:
|
|
4019
|
+
LogFilesDataSourceSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4020
|
+
|
|
4021
|
+
@pulumi.input_type
|
|
4022
|
+
class LogFilesDataSourceSettingsArgs:
|
|
4023
|
+
def __init__(__self__, *,
|
|
4024
|
+
text: Optional[pulumi.Input['LogFileSettingsTextArgs']] = None):
|
|
4025
|
+
"""
|
|
4026
|
+
The log files specific settings.
|
|
4027
|
+
:param pulumi.Input['LogFileSettingsTextArgs'] text: Text settings
|
|
4028
|
+
"""
|
|
4029
|
+
if text is not None:
|
|
4030
|
+
pulumi.set(__self__, "text", text)
|
|
4031
|
+
|
|
4032
|
+
@property
|
|
4033
|
+
@pulumi.getter
|
|
4034
|
+
def text(self) -> Optional[pulumi.Input['LogFileSettingsTextArgs']]:
|
|
2578
4035
|
"""
|
|
2579
|
-
|
|
4036
|
+
Text settings
|
|
2580
4037
|
"""
|
|
2581
|
-
return pulumi.get(self, "
|
|
4038
|
+
return pulumi.get(self, "text")
|
|
2582
4039
|
|
|
2583
|
-
@
|
|
2584
|
-
def
|
|
2585
|
-
pulumi.set(self, "
|
|
4040
|
+
@text.setter
|
|
4041
|
+
def text(self, value: Optional[pulumi.Input['LogFileSettingsTextArgs']]):
|
|
4042
|
+
pulumi.set(self, "text", value)
|
|
2586
4043
|
|
|
2587
4044
|
|
|
2588
4045
|
if not MYPY:
|
|
2589
|
-
class
|
|
4046
|
+
class LogFilesDataSourceArgsDict(TypedDict):
|
|
2590
4047
|
"""
|
|
2591
|
-
|
|
4048
|
+
Definition of which custom log files will be collected by this data collection rule
|
|
2592
4049
|
"""
|
|
2593
|
-
|
|
4050
|
+
file_patterns: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
2594
4051
|
"""
|
|
2595
|
-
|
|
4052
|
+
File Patterns where the log files are located
|
|
2596
4053
|
"""
|
|
2597
|
-
|
|
4054
|
+
format: pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']]
|
|
2598
4055
|
"""
|
|
2599
|
-
|
|
4056
|
+
The data format of the log files
|
|
4057
|
+
"""
|
|
4058
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
4059
|
+
"""
|
|
4060
|
+
List of streams that this data source will be sent to.
|
|
4061
|
+
A stream indicates what schema will be used for this data source
|
|
4062
|
+
"""
|
|
4063
|
+
name: NotRequired[pulumi.Input[str]]
|
|
4064
|
+
"""
|
|
4065
|
+
A friendly name for the data source.
|
|
4066
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
4067
|
+
"""
|
|
4068
|
+
settings: NotRequired[pulumi.Input['LogFilesDataSourceSettingsArgsDict']]
|
|
4069
|
+
"""
|
|
4070
|
+
The log files specific settings.
|
|
2600
4071
|
"""
|
|
2601
4072
|
elif False:
|
|
2602
|
-
|
|
4073
|
+
LogFilesDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
2603
4074
|
|
|
2604
4075
|
@pulumi.input_type
|
|
2605
|
-
class
|
|
4076
|
+
class LogFilesDataSourceArgs:
|
|
2606
4077
|
def __init__(__self__, *,
|
|
2607
|
-
|
|
2608
|
-
|
|
4078
|
+
file_patterns: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
4079
|
+
format: pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']],
|
|
4080
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
4081
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
4082
|
+
settings: Optional[pulumi.Input['LogFilesDataSourceSettingsArgs']] = None):
|
|
4083
|
+
"""
|
|
4084
|
+
Definition of which custom log files will be collected by this data collection rule
|
|
4085
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] file_patterns: File Patterns where the log files are located
|
|
4086
|
+
:param pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']] format: The data format of the log files
|
|
4087
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] streams: List of streams that this data source will be sent to.
|
|
4088
|
+
A stream indicates what schema will be used for this data source
|
|
4089
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
4090
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
4091
|
+
:param pulumi.Input['LogFilesDataSourceSettingsArgs'] settings: The log files specific settings.
|
|
4092
|
+
"""
|
|
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)
|
|
4100
|
+
|
|
4101
|
+
@property
|
|
4102
|
+
@pulumi.getter(name="filePatterns")
|
|
4103
|
+
def file_patterns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2609
4104
|
"""
|
|
2610
|
-
|
|
2611
|
-
:param pulumi.Input[Union[str, 'JsonMapperElement']] destination: Define the destination's element. The element is the body or the attributes of the message, to which the json array mapper will write the output map.
|
|
2612
|
-
:param pulumi.Input[str] field_name: Define a destination field name under the given element. Leaving this empty, means the root of the element. In case element=attributes and fieldName is empty, the object's attributes themselves will contain the key value output pairs.
|
|
4105
|
+
File Patterns where the log files are located
|
|
2613
4106
|
"""
|
|
2614
|
-
|
|
2615
|
-
|
|
2616
|
-
|
|
2617
|
-
|
|
2618
|
-
|
|
2619
|
-
pulumi.set(__self__, "field_name", field_name)
|
|
4107
|
+
return pulumi.get(self, "file_patterns")
|
|
4108
|
+
|
|
4109
|
+
@file_patterns.setter
|
|
4110
|
+
def file_patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
4111
|
+
pulumi.set(self, "file_patterns", value)
|
|
2620
4112
|
|
|
2621
4113
|
@property
|
|
2622
4114
|
@pulumi.getter
|
|
2623
|
-
def
|
|
4115
|
+
def format(self) -> pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']]:
|
|
2624
4116
|
"""
|
|
2625
|
-
|
|
4117
|
+
The data format of the log files
|
|
2626
4118
|
"""
|
|
2627
|
-
return pulumi.get(self, "
|
|
4119
|
+
return pulumi.get(self, "format")
|
|
2628
4120
|
|
|
2629
|
-
@
|
|
2630
|
-
def
|
|
2631
|
-
pulumi.set(self, "
|
|
4121
|
+
@format.setter
|
|
4122
|
+
def format(self, value: pulumi.Input[Union[str, 'KnownLogFilesDataSourceFormat']]):
|
|
4123
|
+
pulumi.set(self, "format", value)
|
|
2632
4124
|
|
|
2633
4125
|
@property
|
|
2634
|
-
@pulumi.getter
|
|
2635
|
-
def
|
|
4126
|
+
@pulumi.getter
|
|
4127
|
+
def streams(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2636
4128
|
"""
|
|
2637
|
-
|
|
4129
|
+
List of streams that this data source will be sent to.
|
|
4130
|
+
A stream indicates what schema will be used for this data source
|
|
2638
4131
|
"""
|
|
2639
|
-
return pulumi.get(self, "
|
|
2640
|
-
|
|
2641
|
-
@field_name.setter
|
|
2642
|
-
def field_name(self, value: Optional[pulumi.Input[str]]):
|
|
2643
|
-
pulumi.set(self, "field_name", value)
|
|
4132
|
+
return pulumi.get(self, "streams")
|
|
2644
4133
|
|
|
4134
|
+
@streams.setter
|
|
4135
|
+
def streams(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
4136
|
+
pulumi.set(self, "streams", value)
|
|
2645
4137
|
|
|
2646
|
-
|
|
2647
|
-
|
|
2648
|
-
|
|
2649
|
-
JsonArrayMapper source field used to describe the field from which the json array will be read.
|
|
2650
|
-
"""
|
|
2651
|
-
field_name: NotRequired[pulumi.Input[str]]
|
|
4138
|
+
@property
|
|
4139
|
+
@pulumi.getter
|
|
4140
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2652
4141
|
"""
|
|
2653
|
-
|
|
4142
|
+
A friendly name for the data source.
|
|
4143
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
2654
4144
|
"""
|
|
2655
|
-
|
|
2656
|
-
JsonMapperSourceFieldArgsDict: TypeAlias = Mapping[str, Any]
|
|
4145
|
+
return pulumi.get(self, "name")
|
|
2657
4146
|
|
|
2658
|
-
@
|
|
2659
|
-
|
|
2660
|
-
|
|
2661
|
-
field_name: Optional[pulumi.Input[str]] = None):
|
|
2662
|
-
"""
|
|
2663
|
-
JsonArrayMapper source field used to describe the field from which the json array will be read.
|
|
2664
|
-
:param pulumi.Input[str] field_name: Define a source field name from which the json array mapper will read the json array. Leaving this empty, means reading the body of the message itself.
|
|
2665
|
-
"""
|
|
2666
|
-
if field_name is not None:
|
|
2667
|
-
pulumi.set(__self__, "field_name", field_name)
|
|
4147
|
+
@name.setter
|
|
4148
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
4149
|
+
pulumi.set(self, "name", value)
|
|
2668
4150
|
|
|
2669
4151
|
@property
|
|
2670
|
-
@pulumi.getter
|
|
2671
|
-
def
|
|
4152
|
+
@pulumi.getter
|
|
4153
|
+
def settings(self) -> Optional[pulumi.Input['LogFilesDataSourceSettingsArgs']]:
|
|
2672
4154
|
"""
|
|
2673
|
-
|
|
4155
|
+
The log files specific settings.
|
|
2674
4156
|
"""
|
|
2675
|
-
return pulumi.get(self, "
|
|
4157
|
+
return pulumi.get(self, "settings")
|
|
2676
4158
|
|
|
2677
|
-
@
|
|
2678
|
-
def
|
|
2679
|
-
pulumi.set(self, "
|
|
4159
|
+
@settings.setter
|
|
4160
|
+
def settings(self, value: Optional[pulumi.Input['LogFilesDataSourceSettingsArgs']]):
|
|
4161
|
+
pulumi.set(self, "settings", value)
|
|
2680
4162
|
|
|
2681
4163
|
|
|
2682
4164
|
if not MYPY:
|
|
@@ -3362,6 +4844,65 @@ class MetricTriggerArgs:
|
|
|
3362
4844
|
pulumi.set(self, "metric_resource_location", value)
|
|
3363
4845
|
|
|
3364
4846
|
|
|
4847
|
+
if not MYPY:
|
|
4848
|
+
class MonitoringAccountDestinationArgsDict(TypedDict):
|
|
4849
|
+
"""
|
|
4850
|
+
Monitoring account destination.
|
|
4851
|
+
"""
|
|
4852
|
+
account_resource_id: NotRequired[pulumi.Input[str]]
|
|
4853
|
+
"""
|
|
4854
|
+
The resource ID of the monitoring account.
|
|
4855
|
+
"""
|
|
4856
|
+
name: NotRequired[pulumi.Input[str]]
|
|
4857
|
+
"""
|
|
4858
|
+
A friendly name for the destination.
|
|
4859
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
4860
|
+
"""
|
|
4861
|
+
elif False:
|
|
4862
|
+
MonitoringAccountDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
4863
|
+
|
|
4864
|
+
@pulumi.input_type
|
|
4865
|
+
class MonitoringAccountDestinationArgs:
|
|
4866
|
+
def __init__(__self__, *,
|
|
4867
|
+
account_resource_id: Optional[pulumi.Input[str]] = None,
|
|
4868
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
4869
|
+
"""
|
|
4870
|
+
Monitoring account destination.
|
|
4871
|
+
:param pulumi.Input[str] account_resource_id: The resource ID of the monitoring account.
|
|
4872
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
4873
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
4874
|
+
"""
|
|
4875
|
+
if account_resource_id is not None:
|
|
4876
|
+
pulumi.set(__self__, "account_resource_id", account_resource_id)
|
|
4877
|
+
if name is not None:
|
|
4878
|
+
pulumi.set(__self__, "name", name)
|
|
4879
|
+
|
|
4880
|
+
@property
|
|
4881
|
+
@pulumi.getter(name="accountResourceId")
|
|
4882
|
+
def account_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
4883
|
+
"""
|
|
4884
|
+
The resource ID of the monitoring account.
|
|
4885
|
+
"""
|
|
4886
|
+
return pulumi.get(self, "account_resource_id")
|
|
4887
|
+
|
|
4888
|
+
@account_resource_id.setter
|
|
4889
|
+
def account_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
4890
|
+
pulumi.set(self, "account_resource_id", value)
|
|
4891
|
+
|
|
4892
|
+
@property
|
|
4893
|
+
@pulumi.getter
|
|
4894
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
4895
|
+
"""
|
|
4896
|
+
A friendly name for the destination.
|
|
4897
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
4898
|
+
"""
|
|
4899
|
+
return pulumi.get(self, "name")
|
|
4900
|
+
|
|
4901
|
+
@name.setter
|
|
4902
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
4903
|
+
pulumi.set(self, "name", value)
|
|
4904
|
+
|
|
4905
|
+
|
|
3365
4906
|
if not MYPY:
|
|
3366
4907
|
class NetworkingConfigurationArgsDict(TypedDict):
|
|
3367
4908
|
"""
|
|
@@ -3566,6 +5107,116 @@ class OtlpReceiverArgs:
|
|
|
3566
5107
|
pulumi.set(self, "endpoint", value)
|
|
3567
5108
|
|
|
3568
5109
|
|
|
5110
|
+
if not MYPY:
|
|
5111
|
+
class PerfCounterDataSourceArgsDict(TypedDict):
|
|
5112
|
+
"""
|
|
5113
|
+
Definition of which performance counters will be collected and how they will be collected by this data collection rule.
|
|
5114
|
+
Collected from both Windows and Linux machines where the counter is present.
|
|
5115
|
+
"""
|
|
5116
|
+
counter_specifiers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5117
|
+
"""
|
|
5118
|
+
A list of specifier names of the performance counters you want to collect.
|
|
5119
|
+
Use a wildcard (*) to collect a counter for all instances.
|
|
5120
|
+
To get a list of performance counters on Windows, run the command 'typeperf'.
|
|
5121
|
+
"""
|
|
5122
|
+
name: NotRequired[pulumi.Input[str]]
|
|
5123
|
+
"""
|
|
5124
|
+
A friendly name for the data source.
|
|
5125
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5126
|
+
"""
|
|
5127
|
+
sampling_frequency_in_seconds: NotRequired[pulumi.Input[int]]
|
|
5128
|
+
"""
|
|
5129
|
+
The number of seconds between consecutive counter measurements (samples).
|
|
5130
|
+
"""
|
|
5131
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPerfCounterDataSourceStreams']]]]]
|
|
5132
|
+
"""
|
|
5133
|
+
List of streams that this data source will be sent to.
|
|
5134
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
5135
|
+
"""
|
|
5136
|
+
elif False:
|
|
5137
|
+
PerfCounterDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
5138
|
+
|
|
5139
|
+
@pulumi.input_type
|
|
5140
|
+
class PerfCounterDataSourceArgs:
|
|
5141
|
+
def __init__(__self__, *,
|
|
5142
|
+
counter_specifiers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
5143
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
5144
|
+
sampling_frequency_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
5145
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPerfCounterDataSourceStreams']]]]] = None):
|
|
5146
|
+
"""
|
|
5147
|
+
Definition of which performance counters will be collected and how they will be collected by this data collection rule.
|
|
5148
|
+
Collected from both Windows and Linux machines where the counter is present.
|
|
5149
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] counter_specifiers: A list of specifier names of the performance counters you want to collect.
|
|
5150
|
+
Use a wildcard (*) to collect a counter for all instances.
|
|
5151
|
+
To get a list of performance counters on Windows, run the command 'typeperf'.
|
|
5152
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
5153
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5154
|
+
:param pulumi.Input[int] sampling_frequency_in_seconds: The number of seconds between consecutive counter measurements (samples).
|
|
5155
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPerfCounterDataSourceStreams']]]] streams: List of streams that this data source will be sent to.
|
|
5156
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
5157
|
+
"""
|
|
5158
|
+
if counter_specifiers is not None:
|
|
5159
|
+
pulumi.set(__self__, "counter_specifiers", counter_specifiers)
|
|
5160
|
+
if name is not None:
|
|
5161
|
+
pulumi.set(__self__, "name", name)
|
|
5162
|
+
if sampling_frequency_in_seconds is not None:
|
|
5163
|
+
pulumi.set(__self__, "sampling_frequency_in_seconds", sampling_frequency_in_seconds)
|
|
5164
|
+
if streams is not None:
|
|
5165
|
+
pulumi.set(__self__, "streams", streams)
|
|
5166
|
+
|
|
5167
|
+
@property
|
|
5168
|
+
@pulumi.getter(name="counterSpecifiers")
|
|
5169
|
+
def counter_specifiers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
5170
|
+
"""
|
|
5171
|
+
A list of specifier names of the performance counters you want to collect.
|
|
5172
|
+
Use a wildcard (*) to collect a counter for all instances.
|
|
5173
|
+
To get a list of performance counters on Windows, run the command 'typeperf'.
|
|
5174
|
+
"""
|
|
5175
|
+
return pulumi.get(self, "counter_specifiers")
|
|
5176
|
+
|
|
5177
|
+
@counter_specifiers.setter
|
|
5178
|
+
def counter_specifiers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
5179
|
+
pulumi.set(self, "counter_specifiers", value)
|
|
5180
|
+
|
|
5181
|
+
@property
|
|
5182
|
+
@pulumi.getter
|
|
5183
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
5184
|
+
"""
|
|
5185
|
+
A friendly name for the data source.
|
|
5186
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5187
|
+
"""
|
|
5188
|
+
return pulumi.get(self, "name")
|
|
5189
|
+
|
|
5190
|
+
@name.setter
|
|
5191
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
5192
|
+
pulumi.set(self, "name", value)
|
|
5193
|
+
|
|
5194
|
+
@property
|
|
5195
|
+
@pulumi.getter(name="samplingFrequencyInSeconds")
|
|
5196
|
+
def sampling_frequency_in_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
5197
|
+
"""
|
|
5198
|
+
The number of seconds between consecutive counter measurements (samples).
|
|
5199
|
+
"""
|
|
5200
|
+
return pulumi.get(self, "sampling_frequency_in_seconds")
|
|
5201
|
+
|
|
5202
|
+
@sampling_frequency_in_seconds.setter
|
|
5203
|
+
def sampling_frequency_in_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
5204
|
+
pulumi.set(self, "sampling_frequency_in_seconds", value)
|
|
5205
|
+
|
|
5206
|
+
@property
|
|
5207
|
+
@pulumi.getter
|
|
5208
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPerfCounterDataSourceStreams']]]]]:
|
|
5209
|
+
"""
|
|
5210
|
+
List of streams that this data source will be sent to.
|
|
5211
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
5212
|
+
"""
|
|
5213
|
+
return pulumi.get(self, "streams")
|
|
5214
|
+
|
|
5215
|
+
@streams.setter
|
|
5216
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPerfCounterDataSourceStreams']]]]]):
|
|
5217
|
+
pulumi.set(self, "streams", value)
|
|
5218
|
+
|
|
5219
|
+
|
|
3569
5220
|
if not MYPY:
|
|
3570
5221
|
class PersistenceConfigurationsArgsDict(TypedDict):
|
|
3571
5222
|
"""
|
|
@@ -3845,6 +5496,64 @@ class PipelineArgs:
|
|
|
3845
5496
|
pulumi.set(self, "processors", value)
|
|
3846
5497
|
|
|
3847
5498
|
|
|
5499
|
+
if not MYPY:
|
|
5500
|
+
class PlatformTelemetryDataSourceArgsDict(TypedDict):
|
|
5501
|
+
"""
|
|
5502
|
+
Definition of platform telemetry data source configuration
|
|
5503
|
+
"""
|
|
5504
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
5505
|
+
"""
|
|
5506
|
+
List of platform telemetry streams to collect
|
|
5507
|
+
"""
|
|
5508
|
+
name: NotRequired[pulumi.Input[str]]
|
|
5509
|
+
"""
|
|
5510
|
+
A friendly name for the data source.
|
|
5511
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5512
|
+
"""
|
|
5513
|
+
elif False:
|
|
5514
|
+
PlatformTelemetryDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
5515
|
+
|
|
5516
|
+
@pulumi.input_type
|
|
5517
|
+
class PlatformTelemetryDataSourceArgs:
|
|
5518
|
+
def __init__(__self__, *,
|
|
5519
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
5520
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
5521
|
+
"""
|
|
5522
|
+
Definition of platform telemetry data source configuration
|
|
5523
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] streams: List of platform telemetry streams to collect
|
|
5524
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
5525
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5526
|
+
"""
|
|
5527
|
+
pulumi.set(__self__, "streams", streams)
|
|
5528
|
+
if name is not None:
|
|
5529
|
+
pulumi.set(__self__, "name", name)
|
|
5530
|
+
|
|
5531
|
+
@property
|
|
5532
|
+
@pulumi.getter
|
|
5533
|
+
def streams(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
5534
|
+
"""
|
|
5535
|
+
List of platform telemetry streams to collect
|
|
5536
|
+
"""
|
|
5537
|
+
return pulumi.get(self, "streams")
|
|
5538
|
+
|
|
5539
|
+
@streams.setter
|
|
5540
|
+
def streams(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
5541
|
+
pulumi.set(self, "streams", value)
|
|
5542
|
+
|
|
5543
|
+
@property
|
|
5544
|
+
@pulumi.getter
|
|
5545
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
5546
|
+
"""
|
|
5547
|
+
A friendly name for the data source.
|
|
5548
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5549
|
+
"""
|
|
5550
|
+
return pulumi.get(self, "name")
|
|
5551
|
+
|
|
5552
|
+
@name.setter
|
|
5553
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
5554
|
+
pulumi.set(self, "name", value)
|
|
5555
|
+
|
|
5556
|
+
|
|
3848
5557
|
if not MYPY:
|
|
3849
5558
|
class PredictiveAutoscalePolicyArgsDict(TypedDict):
|
|
3850
5559
|
"""
|
|
@@ -4014,40 +5723,125 @@ class ProcessorArgs:
|
|
|
4014
5723
|
pulumi.set(__self__, "batch", batch)
|
|
4015
5724
|
|
|
4016
5725
|
@property
|
|
4017
|
-
@pulumi.getter
|
|
4018
|
-
def name(self) -> pulumi.Input[str]:
|
|
5726
|
+
@pulumi.getter
|
|
5727
|
+
def name(self) -> pulumi.Input[str]:
|
|
5728
|
+
"""
|
|
5729
|
+
The name of processor.
|
|
5730
|
+
"""
|
|
5731
|
+
return pulumi.get(self, "name")
|
|
5732
|
+
|
|
5733
|
+
@name.setter
|
|
5734
|
+
def name(self, value: pulumi.Input[str]):
|
|
5735
|
+
pulumi.set(self, "name", value)
|
|
5736
|
+
|
|
5737
|
+
@property
|
|
5738
|
+
@pulumi.getter
|
|
5739
|
+
def type(self) -> pulumi.Input[Union[str, 'ProcessorType']]:
|
|
5740
|
+
"""
|
|
5741
|
+
The type of processor.
|
|
5742
|
+
"""
|
|
5743
|
+
return pulumi.get(self, "type")
|
|
5744
|
+
|
|
5745
|
+
@type.setter
|
|
5746
|
+
def type(self, value: pulumi.Input[Union[str, 'ProcessorType']]):
|
|
5747
|
+
pulumi.set(self, "type", value)
|
|
5748
|
+
|
|
5749
|
+
@property
|
|
5750
|
+
@pulumi.getter
|
|
5751
|
+
def batch(self) -> Optional[pulumi.Input['BatchProcessorArgs']]:
|
|
5752
|
+
"""
|
|
5753
|
+
Batch processor configurations.
|
|
5754
|
+
"""
|
|
5755
|
+
return pulumi.get(self, "batch")
|
|
5756
|
+
|
|
5757
|
+
@batch.setter
|
|
5758
|
+
def batch(self, value: Optional[pulumi.Input['BatchProcessorArgs']]):
|
|
5759
|
+
pulumi.set(self, "batch", value)
|
|
5760
|
+
|
|
5761
|
+
|
|
5762
|
+
if not MYPY:
|
|
5763
|
+
class PrometheusForwarderDataSourceArgsDict(TypedDict):
|
|
5764
|
+
"""
|
|
5765
|
+
Definition of Prometheus metrics forwarding configuration.
|
|
5766
|
+
"""
|
|
5767
|
+
label_include_filter: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
5768
|
+
"""
|
|
5769
|
+
The list of label inclusion filters in the form of label "name-value" pairs.
|
|
5770
|
+
Currently only one label is supported: 'microsoft_metrics_include_label'.
|
|
5771
|
+
Label values are matched case-insensitively.
|
|
5772
|
+
"""
|
|
5773
|
+
name: NotRequired[pulumi.Input[str]]
|
|
5774
|
+
"""
|
|
5775
|
+
A friendly name for the data source.
|
|
5776
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5777
|
+
"""
|
|
5778
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPrometheusForwarderDataSourceStreams']]]]]
|
|
5779
|
+
"""
|
|
5780
|
+
List of streams that this data source will be sent to.
|
|
5781
|
+
"""
|
|
5782
|
+
elif False:
|
|
5783
|
+
PrometheusForwarderDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
5784
|
+
|
|
5785
|
+
@pulumi.input_type
|
|
5786
|
+
class PrometheusForwarderDataSourceArgs:
|
|
5787
|
+
def __init__(__self__, *,
|
|
5788
|
+
label_include_filter: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
5789
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
5790
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPrometheusForwarderDataSourceStreams']]]]] = None):
|
|
5791
|
+
"""
|
|
5792
|
+
Definition of Prometheus metrics forwarding configuration.
|
|
5793
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] label_include_filter: The list of label inclusion filters in the form of label "name-value" pairs.
|
|
5794
|
+
Currently only one label is supported: 'microsoft_metrics_include_label'.
|
|
5795
|
+
Label values are matched case-insensitively.
|
|
5796
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
5797
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
5798
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPrometheusForwarderDataSourceStreams']]]] streams: List of streams that this data source will be sent to.
|
|
5799
|
+
"""
|
|
5800
|
+
if label_include_filter is not None:
|
|
5801
|
+
pulumi.set(__self__, "label_include_filter", label_include_filter)
|
|
5802
|
+
if name is not None:
|
|
5803
|
+
pulumi.set(__self__, "name", name)
|
|
5804
|
+
if streams is not None:
|
|
5805
|
+
pulumi.set(__self__, "streams", streams)
|
|
5806
|
+
|
|
5807
|
+
@property
|
|
5808
|
+
@pulumi.getter(name="labelIncludeFilter")
|
|
5809
|
+
def label_include_filter(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
4019
5810
|
"""
|
|
4020
|
-
The
|
|
5811
|
+
The list of label inclusion filters in the form of label "name-value" pairs.
|
|
5812
|
+
Currently only one label is supported: 'microsoft_metrics_include_label'.
|
|
5813
|
+
Label values are matched case-insensitively.
|
|
4021
5814
|
"""
|
|
4022
|
-
return pulumi.get(self, "
|
|
5815
|
+
return pulumi.get(self, "label_include_filter")
|
|
4023
5816
|
|
|
4024
|
-
@
|
|
4025
|
-
def
|
|
4026
|
-
pulumi.set(self, "
|
|
5817
|
+
@label_include_filter.setter
|
|
5818
|
+
def label_include_filter(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
5819
|
+
pulumi.set(self, "label_include_filter", value)
|
|
4027
5820
|
|
|
4028
5821
|
@property
|
|
4029
5822
|
@pulumi.getter
|
|
4030
|
-
def
|
|
5823
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
4031
5824
|
"""
|
|
4032
|
-
|
|
5825
|
+
A friendly name for the data source.
|
|
5826
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
4033
5827
|
"""
|
|
4034
|
-
return pulumi.get(self, "
|
|
5828
|
+
return pulumi.get(self, "name")
|
|
4035
5829
|
|
|
4036
|
-
@
|
|
4037
|
-
def
|
|
4038
|
-
pulumi.set(self, "
|
|
5830
|
+
@name.setter
|
|
5831
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
5832
|
+
pulumi.set(self, "name", value)
|
|
4039
5833
|
|
|
4040
5834
|
@property
|
|
4041
5835
|
@pulumi.getter
|
|
4042
|
-
def
|
|
5836
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPrometheusForwarderDataSourceStreams']]]]]:
|
|
4043
5837
|
"""
|
|
4044
|
-
|
|
5838
|
+
List of streams that this data source will be sent to.
|
|
4045
5839
|
"""
|
|
4046
|
-
return pulumi.get(self, "
|
|
5840
|
+
return pulumi.get(self, "streams")
|
|
4047
5841
|
|
|
4048
|
-
@
|
|
4049
|
-
def
|
|
4050
|
-
pulumi.set(self, "
|
|
5842
|
+
@streams.setter
|
|
5843
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownPrometheusForwarderDataSourceStreams']]]]]):
|
|
5844
|
+
pulumi.set(self, "streams", value)
|
|
4051
5845
|
|
|
4052
5846
|
|
|
4053
5847
|
if not MYPY:
|
|
@@ -5116,6 +6910,192 @@ class SmsReceiverArgs:
|
|
|
5116
6910
|
pulumi.set(self, "phone_number", value)
|
|
5117
6911
|
|
|
5118
6912
|
|
|
6913
|
+
if not MYPY:
|
|
6914
|
+
class StorageBlobDestinationArgsDict(TypedDict):
|
|
6915
|
+
container_name: NotRequired[pulumi.Input[str]]
|
|
6916
|
+
"""
|
|
6917
|
+
The container name of the Storage Blob.
|
|
6918
|
+
"""
|
|
6919
|
+
name: NotRequired[pulumi.Input[str]]
|
|
6920
|
+
"""
|
|
6921
|
+
A friendly name for the destination.
|
|
6922
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
6923
|
+
"""
|
|
6924
|
+
storage_account_resource_id: NotRequired[pulumi.Input[str]]
|
|
6925
|
+
"""
|
|
6926
|
+
The resource ID of the storage account.
|
|
6927
|
+
"""
|
|
6928
|
+
elif False:
|
|
6929
|
+
StorageBlobDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
6930
|
+
|
|
6931
|
+
@pulumi.input_type
|
|
6932
|
+
class StorageBlobDestinationArgs:
|
|
6933
|
+
def __init__(__self__, *,
|
|
6934
|
+
container_name: Optional[pulumi.Input[str]] = None,
|
|
6935
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
6936
|
+
storage_account_resource_id: Optional[pulumi.Input[str]] = None):
|
|
6937
|
+
"""
|
|
6938
|
+
:param pulumi.Input[str] container_name: The container name of the Storage Blob.
|
|
6939
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
6940
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
6941
|
+
:param pulumi.Input[str] storage_account_resource_id: The resource ID of the storage account.
|
|
6942
|
+
"""
|
|
6943
|
+
if container_name is not None:
|
|
6944
|
+
pulumi.set(__self__, "container_name", container_name)
|
|
6945
|
+
if name is not None:
|
|
6946
|
+
pulumi.set(__self__, "name", name)
|
|
6947
|
+
if storage_account_resource_id is not None:
|
|
6948
|
+
pulumi.set(__self__, "storage_account_resource_id", storage_account_resource_id)
|
|
6949
|
+
|
|
6950
|
+
@property
|
|
6951
|
+
@pulumi.getter(name="containerName")
|
|
6952
|
+
def container_name(self) -> Optional[pulumi.Input[str]]:
|
|
6953
|
+
"""
|
|
6954
|
+
The container name of the Storage Blob.
|
|
6955
|
+
"""
|
|
6956
|
+
return pulumi.get(self, "container_name")
|
|
6957
|
+
|
|
6958
|
+
@container_name.setter
|
|
6959
|
+
def container_name(self, value: Optional[pulumi.Input[str]]):
|
|
6960
|
+
pulumi.set(self, "container_name", value)
|
|
6961
|
+
|
|
6962
|
+
@property
|
|
6963
|
+
@pulumi.getter
|
|
6964
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
6965
|
+
"""
|
|
6966
|
+
A friendly name for the destination.
|
|
6967
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
6968
|
+
"""
|
|
6969
|
+
return pulumi.get(self, "name")
|
|
6970
|
+
|
|
6971
|
+
@name.setter
|
|
6972
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
6973
|
+
pulumi.set(self, "name", value)
|
|
6974
|
+
|
|
6975
|
+
@property
|
|
6976
|
+
@pulumi.getter(name="storageAccountResourceId")
|
|
6977
|
+
def storage_account_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
6978
|
+
"""
|
|
6979
|
+
The resource ID of the storage account.
|
|
6980
|
+
"""
|
|
6981
|
+
return pulumi.get(self, "storage_account_resource_id")
|
|
6982
|
+
|
|
6983
|
+
@storage_account_resource_id.setter
|
|
6984
|
+
def storage_account_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
6985
|
+
pulumi.set(self, "storage_account_resource_id", value)
|
|
6986
|
+
|
|
6987
|
+
|
|
6988
|
+
if not MYPY:
|
|
6989
|
+
class StorageTableDestinationArgsDict(TypedDict):
|
|
6990
|
+
name: NotRequired[pulumi.Input[str]]
|
|
6991
|
+
"""
|
|
6992
|
+
A friendly name for the destination.
|
|
6993
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
6994
|
+
"""
|
|
6995
|
+
storage_account_resource_id: NotRequired[pulumi.Input[str]]
|
|
6996
|
+
"""
|
|
6997
|
+
The resource ID of the storage account.
|
|
6998
|
+
"""
|
|
6999
|
+
table_name: NotRequired[pulumi.Input[str]]
|
|
7000
|
+
"""
|
|
7001
|
+
The name of the Storage Table.
|
|
7002
|
+
"""
|
|
7003
|
+
elif False:
|
|
7004
|
+
StorageTableDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
7005
|
+
|
|
7006
|
+
@pulumi.input_type
|
|
7007
|
+
class StorageTableDestinationArgs:
|
|
7008
|
+
def __init__(__self__, *,
|
|
7009
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
7010
|
+
storage_account_resource_id: Optional[pulumi.Input[str]] = None,
|
|
7011
|
+
table_name: Optional[pulumi.Input[str]] = None):
|
|
7012
|
+
"""
|
|
7013
|
+
:param pulumi.Input[str] name: A friendly name for the destination.
|
|
7014
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
7015
|
+
:param pulumi.Input[str] storage_account_resource_id: The resource ID of the storage account.
|
|
7016
|
+
:param pulumi.Input[str] table_name: The name of the Storage Table.
|
|
7017
|
+
"""
|
|
7018
|
+
if name is not None:
|
|
7019
|
+
pulumi.set(__self__, "name", name)
|
|
7020
|
+
if storage_account_resource_id is not None:
|
|
7021
|
+
pulumi.set(__self__, "storage_account_resource_id", storage_account_resource_id)
|
|
7022
|
+
if table_name is not None:
|
|
7023
|
+
pulumi.set(__self__, "table_name", table_name)
|
|
7024
|
+
|
|
7025
|
+
@property
|
|
7026
|
+
@pulumi.getter
|
|
7027
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
7028
|
+
"""
|
|
7029
|
+
A friendly name for the destination.
|
|
7030
|
+
This name should be unique across all destinations (regardless of type) within the data collection rule.
|
|
7031
|
+
"""
|
|
7032
|
+
return pulumi.get(self, "name")
|
|
7033
|
+
|
|
7034
|
+
@name.setter
|
|
7035
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
7036
|
+
pulumi.set(self, "name", value)
|
|
7037
|
+
|
|
7038
|
+
@property
|
|
7039
|
+
@pulumi.getter(name="storageAccountResourceId")
|
|
7040
|
+
def storage_account_resource_id(self) -> Optional[pulumi.Input[str]]:
|
|
7041
|
+
"""
|
|
7042
|
+
The resource ID of the storage account.
|
|
7043
|
+
"""
|
|
7044
|
+
return pulumi.get(self, "storage_account_resource_id")
|
|
7045
|
+
|
|
7046
|
+
@storage_account_resource_id.setter
|
|
7047
|
+
def storage_account_resource_id(self, value: Optional[pulumi.Input[str]]):
|
|
7048
|
+
pulumi.set(self, "storage_account_resource_id", value)
|
|
7049
|
+
|
|
7050
|
+
@property
|
|
7051
|
+
@pulumi.getter(name="tableName")
|
|
7052
|
+
def table_name(self) -> Optional[pulumi.Input[str]]:
|
|
7053
|
+
"""
|
|
7054
|
+
The name of the Storage Table.
|
|
7055
|
+
"""
|
|
7056
|
+
return pulumi.get(self, "table_name")
|
|
7057
|
+
|
|
7058
|
+
@table_name.setter
|
|
7059
|
+
def table_name(self, value: Optional[pulumi.Input[str]]):
|
|
7060
|
+
pulumi.set(self, "table_name", value)
|
|
7061
|
+
|
|
7062
|
+
|
|
7063
|
+
if not MYPY:
|
|
7064
|
+
class StreamDeclarationArgsDict(TypedDict):
|
|
7065
|
+
"""
|
|
7066
|
+
Declaration of a custom stream.
|
|
7067
|
+
"""
|
|
7068
|
+
columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['ColumnDefinitionArgsDict']]]]
|
|
7069
|
+
"""
|
|
7070
|
+
List of columns used by data in this stream.
|
|
7071
|
+
"""
|
|
7072
|
+
elif False:
|
|
7073
|
+
StreamDeclarationArgsDict: TypeAlias = Mapping[str, Any]
|
|
7074
|
+
|
|
7075
|
+
@pulumi.input_type
|
|
7076
|
+
class StreamDeclarationArgs:
|
|
7077
|
+
def __init__(__self__, *,
|
|
7078
|
+
columns: Optional[pulumi.Input[Sequence[pulumi.Input['ColumnDefinitionArgs']]]] = None):
|
|
7079
|
+
"""
|
|
7080
|
+
Declaration of a custom stream.
|
|
7081
|
+
:param pulumi.Input[Sequence[pulumi.Input['ColumnDefinitionArgs']]] columns: List of columns used by data in this stream.
|
|
7082
|
+
"""
|
|
7083
|
+
if columns is not None:
|
|
7084
|
+
pulumi.set(__self__, "columns", columns)
|
|
7085
|
+
|
|
7086
|
+
@property
|
|
7087
|
+
@pulumi.getter
|
|
7088
|
+
def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ColumnDefinitionArgs']]]]:
|
|
7089
|
+
"""
|
|
7090
|
+
List of columns used by data in this stream.
|
|
7091
|
+
"""
|
|
7092
|
+
return pulumi.get(self, "columns")
|
|
7093
|
+
|
|
7094
|
+
@columns.setter
|
|
7095
|
+
def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ColumnDefinitionArgs']]]]):
|
|
7096
|
+
pulumi.set(self, "columns", value)
|
|
7097
|
+
|
|
7098
|
+
|
|
5119
7099
|
if not MYPY:
|
|
5120
7100
|
class SubscriptionLogSettingsArgsDict(TypedDict):
|
|
5121
7101
|
"""
|
|
@@ -5191,6 +7171,110 @@ class SubscriptionLogSettingsArgs:
|
|
|
5191
7171
|
pulumi.set(self, "category_group", value)
|
|
5192
7172
|
|
|
5193
7173
|
|
|
7174
|
+
if not MYPY:
|
|
7175
|
+
class SyslogDataSourceArgsDict(TypedDict):
|
|
7176
|
+
"""
|
|
7177
|
+
Definition of which syslog data will be collected and how it will be collected.
|
|
7178
|
+
Only collected from Linux machines.
|
|
7179
|
+
"""
|
|
7180
|
+
facility_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceFacilityNames']]]]]
|
|
7181
|
+
"""
|
|
7182
|
+
The list of facility names.
|
|
7183
|
+
"""
|
|
7184
|
+
log_levels: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceLogLevels']]]]]
|
|
7185
|
+
"""
|
|
7186
|
+
The log levels to collect.
|
|
7187
|
+
"""
|
|
7188
|
+
name: NotRequired[pulumi.Input[str]]
|
|
7189
|
+
"""
|
|
7190
|
+
A friendly name for the data source.
|
|
7191
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7192
|
+
"""
|
|
7193
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceStreams']]]]]
|
|
7194
|
+
"""
|
|
7195
|
+
List of streams that this data source will be sent to.
|
|
7196
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7197
|
+
"""
|
|
7198
|
+
elif False:
|
|
7199
|
+
SyslogDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
7200
|
+
|
|
7201
|
+
@pulumi.input_type
|
|
7202
|
+
class SyslogDataSourceArgs:
|
|
7203
|
+
def __init__(__self__, *,
|
|
7204
|
+
facility_names: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceFacilityNames']]]]] = None,
|
|
7205
|
+
log_levels: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceLogLevels']]]]] = None,
|
|
7206
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
7207
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceStreams']]]]] = None):
|
|
7208
|
+
"""
|
|
7209
|
+
Definition of which syslog data will be collected and how it will be collected.
|
|
7210
|
+
Only collected from Linux machines.
|
|
7211
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceFacilityNames']]]] facility_names: The list of facility names.
|
|
7212
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceLogLevels']]]] log_levels: The log levels to collect.
|
|
7213
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
7214
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7215
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceStreams']]]] streams: List of streams that this data source will be sent to.
|
|
7216
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7217
|
+
"""
|
|
7218
|
+
if facility_names is not None:
|
|
7219
|
+
pulumi.set(__self__, "facility_names", facility_names)
|
|
7220
|
+
if log_levels is not None:
|
|
7221
|
+
pulumi.set(__self__, "log_levels", log_levels)
|
|
7222
|
+
if name is not None:
|
|
7223
|
+
pulumi.set(__self__, "name", name)
|
|
7224
|
+
if streams is not None:
|
|
7225
|
+
pulumi.set(__self__, "streams", streams)
|
|
7226
|
+
|
|
7227
|
+
@property
|
|
7228
|
+
@pulumi.getter(name="facilityNames")
|
|
7229
|
+
def facility_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceFacilityNames']]]]]:
|
|
7230
|
+
"""
|
|
7231
|
+
The list of facility names.
|
|
7232
|
+
"""
|
|
7233
|
+
return pulumi.get(self, "facility_names")
|
|
7234
|
+
|
|
7235
|
+
@facility_names.setter
|
|
7236
|
+
def facility_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceFacilityNames']]]]]):
|
|
7237
|
+
pulumi.set(self, "facility_names", value)
|
|
7238
|
+
|
|
7239
|
+
@property
|
|
7240
|
+
@pulumi.getter(name="logLevels")
|
|
7241
|
+
def log_levels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceLogLevels']]]]]:
|
|
7242
|
+
"""
|
|
7243
|
+
The log levels to collect.
|
|
7244
|
+
"""
|
|
7245
|
+
return pulumi.get(self, "log_levels")
|
|
7246
|
+
|
|
7247
|
+
@log_levels.setter
|
|
7248
|
+
def log_levels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceLogLevels']]]]]):
|
|
7249
|
+
pulumi.set(self, "log_levels", value)
|
|
7250
|
+
|
|
7251
|
+
@property
|
|
7252
|
+
@pulumi.getter
|
|
7253
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
7254
|
+
"""
|
|
7255
|
+
A friendly name for the data source.
|
|
7256
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7257
|
+
"""
|
|
7258
|
+
return pulumi.get(self, "name")
|
|
7259
|
+
|
|
7260
|
+
@name.setter
|
|
7261
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
7262
|
+
pulumi.set(self, "name", value)
|
|
7263
|
+
|
|
7264
|
+
@property
|
|
7265
|
+
@pulumi.getter
|
|
7266
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceStreams']]]]]:
|
|
7267
|
+
"""
|
|
7268
|
+
List of streams that this data source will be sent to.
|
|
7269
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7270
|
+
"""
|
|
7271
|
+
return pulumi.get(self, "streams")
|
|
7272
|
+
|
|
7273
|
+
@streams.setter
|
|
7274
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownSyslogDataSourceStreams']]]]]):
|
|
7275
|
+
pulumi.set(self, "streams", value)
|
|
7276
|
+
|
|
7277
|
+
|
|
5194
7278
|
if not MYPY:
|
|
5195
7279
|
class SyslogReceiverArgsDict(TypedDict):
|
|
5196
7280
|
"""
|
|
@@ -5763,3 +7847,145 @@ class WebhookReceiverArgs:
|
|
|
5763
7847
|
pulumi.set(self, "use_common_alert_schema", value)
|
|
5764
7848
|
|
|
5765
7849
|
|
|
7850
|
+
if not MYPY:
|
|
7851
|
+
class WindowsEventLogDataSourceArgsDict(TypedDict):
|
|
7852
|
+
"""
|
|
7853
|
+
Definition of which Windows Event Log events will be collected and how they will be collected.
|
|
7854
|
+
Only collected from Windows machines.
|
|
7855
|
+
"""
|
|
7856
|
+
name: NotRequired[pulumi.Input[str]]
|
|
7857
|
+
"""
|
|
7858
|
+
A friendly name for the data source.
|
|
7859
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7860
|
+
"""
|
|
7861
|
+
streams: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownWindowsEventLogDataSourceStreams']]]]]
|
|
7862
|
+
"""
|
|
7863
|
+
List of streams that this data source will be sent to.
|
|
7864
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7865
|
+
"""
|
|
7866
|
+
x_path_queries: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7867
|
+
"""
|
|
7868
|
+
A list of Windows Event Log queries in XPATH format.
|
|
7869
|
+
"""
|
|
7870
|
+
elif False:
|
|
7871
|
+
WindowsEventLogDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
7872
|
+
|
|
7873
|
+
@pulumi.input_type
|
|
7874
|
+
class WindowsEventLogDataSourceArgs:
|
|
7875
|
+
def __init__(__self__, *,
|
|
7876
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
7877
|
+
streams: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownWindowsEventLogDataSourceStreams']]]]] = None,
|
|
7878
|
+
x_path_queries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
7879
|
+
"""
|
|
7880
|
+
Definition of which Windows Event Log events will be collected and how they will be collected.
|
|
7881
|
+
Only collected from Windows machines.
|
|
7882
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
7883
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7884
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownWindowsEventLogDataSourceStreams']]]] streams: List of streams that this data source will be sent to.
|
|
7885
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7886
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] x_path_queries: A list of Windows Event Log queries in XPATH format.
|
|
7887
|
+
"""
|
|
7888
|
+
if name is not None:
|
|
7889
|
+
pulumi.set(__self__, "name", name)
|
|
7890
|
+
if streams is not None:
|
|
7891
|
+
pulumi.set(__self__, "streams", streams)
|
|
7892
|
+
if x_path_queries is not None:
|
|
7893
|
+
pulumi.set(__self__, "x_path_queries", x_path_queries)
|
|
7894
|
+
|
|
7895
|
+
@property
|
|
7896
|
+
@pulumi.getter
|
|
7897
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
7898
|
+
"""
|
|
7899
|
+
A friendly name for the data source.
|
|
7900
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7901
|
+
"""
|
|
7902
|
+
return pulumi.get(self, "name")
|
|
7903
|
+
|
|
7904
|
+
@name.setter
|
|
7905
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
7906
|
+
pulumi.set(self, "name", value)
|
|
7907
|
+
|
|
7908
|
+
@property
|
|
7909
|
+
@pulumi.getter
|
|
7910
|
+
def streams(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownWindowsEventLogDataSourceStreams']]]]]:
|
|
7911
|
+
"""
|
|
7912
|
+
List of streams that this data source will be sent to.
|
|
7913
|
+
A stream indicates what schema will be used for this data and usually what table in Log Analytics the data will be sent to.
|
|
7914
|
+
"""
|
|
7915
|
+
return pulumi.get(self, "streams")
|
|
7916
|
+
|
|
7917
|
+
@streams.setter
|
|
7918
|
+
def streams(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'KnownWindowsEventLogDataSourceStreams']]]]]):
|
|
7919
|
+
pulumi.set(self, "streams", value)
|
|
7920
|
+
|
|
7921
|
+
@property
|
|
7922
|
+
@pulumi.getter(name="xPathQueries")
|
|
7923
|
+
def x_path_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
7924
|
+
"""
|
|
7925
|
+
A list of Windows Event Log queries in XPATH format.
|
|
7926
|
+
"""
|
|
7927
|
+
return pulumi.get(self, "x_path_queries")
|
|
7928
|
+
|
|
7929
|
+
@x_path_queries.setter
|
|
7930
|
+
def x_path_queries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
7931
|
+
pulumi.set(self, "x_path_queries", value)
|
|
7932
|
+
|
|
7933
|
+
|
|
7934
|
+
if not MYPY:
|
|
7935
|
+
class WindowsFirewallLogsDataSourceArgsDict(TypedDict):
|
|
7936
|
+
"""
|
|
7937
|
+
Enables Firewall logs to be collected by this data collection rule.
|
|
7938
|
+
"""
|
|
7939
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
7940
|
+
"""
|
|
7941
|
+
Firewall logs streams
|
|
7942
|
+
"""
|
|
7943
|
+
name: NotRequired[pulumi.Input[str]]
|
|
7944
|
+
"""
|
|
7945
|
+
A friendly name for the data source.
|
|
7946
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7947
|
+
"""
|
|
7948
|
+
elif False:
|
|
7949
|
+
WindowsFirewallLogsDataSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
7950
|
+
|
|
7951
|
+
@pulumi.input_type
|
|
7952
|
+
class WindowsFirewallLogsDataSourceArgs:
|
|
7953
|
+
def __init__(__self__, *,
|
|
7954
|
+
streams: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
7955
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
7956
|
+
"""
|
|
7957
|
+
Enables Firewall logs to be collected by this data collection rule.
|
|
7958
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] streams: Firewall logs streams
|
|
7959
|
+
:param pulumi.Input[str] name: A friendly name for the data source.
|
|
7960
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7961
|
+
"""
|
|
7962
|
+
pulumi.set(__self__, "streams", streams)
|
|
7963
|
+
if name is not None:
|
|
7964
|
+
pulumi.set(__self__, "name", name)
|
|
7965
|
+
|
|
7966
|
+
@property
|
|
7967
|
+
@pulumi.getter
|
|
7968
|
+
def streams(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
7969
|
+
"""
|
|
7970
|
+
Firewall logs streams
|
|
7971
|
+
"""
|
|
7972
|
+
return pulumi.get(self, "streams")
|
|
7973
|
+
|
|
7974
|
+
@streams.setter
|
|
7975
|
+
def streams(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
7976
|
+
pulumi.set(self, "streams", value)
|
|
7977
|
+
|
|
7978
|
+
@property
|
|
7979
|
+
@pulumi.getter
|
|
7980
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
7981
|
+
"""
|
|
7982
|
+
A friendly name for the data source.
|
|
7983
|
+
This name should be unique across all data sources (regardless of type) within the data collection rule.
|
|
7984
|
+
"""
|
|
7985
|
+
return pulumi.get(self, "name")
|
|
7986
|
+
|
|
7987
|
+
@name.setter
|
|
7988
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
7989
|
+
pulumi.set(self, "name", value)
|
|
7990
|
+
|
|
7991
|
+
|