cribl-control-plane 0.4.0b23__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

cribl_control_plane/models/heartbeatmetadata.py

@@ -30,6 +30,45 @@ class HeartbeatMetadataAws(BaseModel):
     tags: Optional[Dict[str, str]] = None
 
 
+class HeartbeatMetadataAzureTypedDict(TypedDict):
+    enabled: bool
+    hostname: NotRequired[str]
+    instance_id: NotRequired[str]
+    name: NotRequired[str]
+    region: NotRequired[str]
+    resource_group: NotRequired[str]
+    subscription_id: NotRequired[str]
+    tags: NotRequired[Dict[str, str]]
+    type: NotRequired[str]
+    zone: NotRequired[str]
+
+
+class HeartbeatMetadataAzure(BaseModel):
+    enabled: bool
+
+    hostname: Optional[str] = None
+
+    instance_id: Annotated[Optional[str], pydantic.Field(alias="instanceId")] = None
+
+    name: Optional[str] = None
+
+    region: Optional[str] = None
+
+    resource_group: Annotated[Optional[str], pydantic.Field(alias="resourceGroup")] = (
+        None
+    )
+
+    subscription_id: Annotated[
+        Optional[str], pydantic.Field(alias="subscriptionId")
+    ] = None
+
+    tags: Optional[Dict[str, str]] = None
+
+    type: Optional[str] = None
+
+    zone: Optional[str] = None
+
+
 class HeartbeatMetadataHostOsTypedDict(TypedDict):
     addresses: List[str]
     enabled: bool
@@ -100,6 +139,7 @@ class HeartbeatMetadataOs(BaseModel):
 
 class HeartbeatMetadataTypedDict(TypedDict):
     aws: NotRequired[HeartbeatMetadataAwsTypedDict]
+    azure: NotRequired[HeartbeatMetadataAzureTypedDict]
     host_os: NotRequired[HeartbeatMetadataHostOsTypedDict]
     kube: NotRequired[HeartbeatMetadataKubeTypedDict]
     os: NotRequired[HeartbeatMetadataOsTypedDict]
@@ -108,6 +148,8 @@ class HeartbeatMetadataTypedDict(TypedDict):
 class HeartbeatMetadata(BaseModel):
     aws: Optional[HeartbeatMetadataAws] = None
 
+    azure: Optional[HeartbeatMetadataAzure] = None
+
     host_os: Annotated[
         Optional[HeartbeatMetadataHostOs], pydantic.Field(alias="hostOs")
     ] = None

cribl_control_plane/models/input.py

@@ -128,10 +128,10 @@ InputTypedDict = TypeAliasType(
         InputCrowdstrikeTypedDict,
         InputEdgePrometheusTypedDict,
         InputOpenTelemetryTypedDict,
-        InputPrometheusTypedDict,
         InputS3TypedDict,
         InputSecurityLakeTypedDict,
         InputMskTypedDict,
+        InputPrometheusTypedDict,
         InputS3InventoryTypedDict,
         InputSplunkSearchTypedDict,
         InputSyslogTypedDict,

cribl_control_plane/models/inputedgeprometheus.py

@@ -260,7 +260,7 @@ class Target(BaseModel):
 
 
 class InputEdgePrometheusRecordType(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
 
     SRV = "SRV"
     A = "A"
@@ -289,17 +289,17 @@ class InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod(
 
 class InputEdgePrometheusSearchFilterTypedDict(TypedDict):
     name: str
-    r"""Search filter attribute name, see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for more information. Attributes can be manually entered if not present in the drop down list"""
+    r"""See https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for information. Attributes can be manually entered if not present in the list."""
     values: List[str]
-    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+    r"""Values to match within this row's attribute. If empty, search will return only running EC2 instances."""
 
 
 class InputEdgePrometheusSearchFilter(BaseModel):
     name: Annotated[str, pydantic.Field(alias="Name")]
-    r"""Search filter attribute name, see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for more information. Attributes can be manually entered if not present in the drop down list"""
+    r"""See https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for information. Attributes can be manually entered if not present in the list."""
 
     values: Annotated[List[str], pydantic.Field(alias="Values")]
-    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+    r"""Values to match within this row's attribute. If empty, search will return only running EC2 instances."""
 
 
 class InputEdgePrometheusSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
@@ -358,7 +358,7 @@ class InputEdgePrometheusTypedDict(TypedDict):
     description: NotRequired[str]
     targets: NotRequired[List[TargetTypedDict]]
     record_type: NotRequired[InputEdgePrometheusRecordType]
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
     scrape_port: NotRequired[float]
     r"""The port number in the metrics URL for discovered targets."""
     name_list: NotRequired[List[str]]
@@ -375,9 +375,9 @@ class InputEdgePrometheusTypedDict(TypedDict):
     aws_secret: NotRequired[str]
     r"""Select or create a stored secret that references your access key and secret key"""
     use_public_ip: NotRequired[bool]
-    r"""Use public IP address for discovered targets. Set to false if the private IP address should be used."""
+    r"""Use public IP address for discovered targets. Disable to use the private IP address."""
     search_filter: NotRequired[List[InputEdgePrometheusSearchFilterTypedDict]]
-    r"""EC2 Instance Search Filter"""
+    r"""Filter to apply when searching for EC2 instances"""
     aws_secret_key: NotRequired[str]
     region: NotRequired[str]
     r"""Region where the EC2 is located"""
@@ -492,7 +492,7 @@ class InputEdgePrometheus(BaseModel):
         ],
         pydantic.Field(alias="recordType"),
     ] = InputEdgePrometheusRecordType.SRV
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
 
     scrape_port: Annotated[Optional[float], pydantic.Field(alias="scrapePort")] = 9090
     r"""The port number in the metrics URL for discovered targets."""
@@ -528,13 +528,13 @@ class InputEdgePrometheus(BaseModel):
     r"""Select or create a stored secret that references your access key and secret key"""
 
     use_public_ip: Annotated[Optional[bool], pydantic.Field(alias="usePublicIp")] = True
-    r"""Use public IP address for discovered targets. Set to false if the private IP address should be used."""
+    r"""Use public IP address for discovered targets. Disable to use the private IP address."""
 
     search_filter: Annotated[
         Optional[List[InputEdgePrometheusSearchFilter]],
         pydantic.Field(alias="searchFilter"),
     ] = None
-    r"""EC2 Instance Search Filter"""
+    r"""Filter to apply when searching for EC2 instances"""
 
     aws_secret_key: Annotated[Optional[str], pydantic.Field(alias="awsSecretKey")] = (
         None

cribl_control_plane/models/inputprometheus.py

@@ -138,7 +138,7 @@ class InputPrometheusDiscoveryType(str, Enum, metaclass=utils.OpenEnumMeta):
 
 
 class InputPrometheusLogLevel(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Collector runtime Log Level"""
+    r"""Collector runtime log level"""
 
     ERROR = "error"
     WARN = "warn"
@@ -169,7 +169,7 @@ class InputPrometheusAuthTypeAuthenticationMethod(
 
 
 class InputPrometheusRecordType(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
 
     SRV = "SRV"
     A = "A"
@@ -198,17 +198,17 @@ class InputPrometheusAwsAuthenticationMethodAuthenticationMethod(
 
 class InputPrometheusSearchFilterTypedDict(TypedDict):
     name: str
-    r"""Search filter attribute name, see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for more information. Attributes can be manually entered if not present in the drop down list"""
+    r"""See https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for information. Attributes can be manually entered if not present in the list."""
     values: List[str]
-    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+    r"""Values to match within this row's attribute. If empty, search will return only running EC2 instances."""
 
 
 class InputPrometheusSearchFilter(BaseModel):
     name: Annotated[str, pydantic.Field(alias="Name")]
-    r"""Search filter attribute name, see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for more information. Attributes can be manually entered if not present in the drop down list"""
+    r"""See https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html for information. Attributes can be manually entered if not present in the list."""
 
     values: Annotated[List[str], pydantic.Field(alias="Values")]
-    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+    r"""Values to match within this row's attribute. If empty, search will return only running EC2 instances."""
 
 
 class InputPrometheusSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
@@ -241,11 +241,13 @@ class InputPrometheusTypedDict(TypedDict):
     discovery_type: NotRequired[InputPrometheusDiscoveryType]
     r"""Target discovery mechanism. Use static to manually enter a list of targets."""
     interval: NotRequired[float]
-    r"""How often in minutes to scrape targets for metrics, 60 must be evenly divisible by the value or save will fail."""
+    r"""How often, in minutes, to scrape targets for metrics. Maximum of 60 minutes. 60 must be evenly divisible by the value you enter."""
     log_level: NotRequired[InputPrometheusLogLevel]
-    r"""Collector runtime Log Level"""
+    r"""Collector runtime log level"""
     reject_unauthorized: NotRequired[bool]
     r"""Reject certificates that cannot be verified against a valid CA, such as self-signed certificates"""
+    timeout: NotRequired[float]
+    r"""Time, in seconds, before aborting HTTP connection attempts; use 0 for no timeout"""
     keep_alive_time: NotRequired[float]
     r"""How often workers should check in with the scheduler to keep job subscription alive"""
     job_timeout: NotRequired[str]
@@ -264,9 +266,9 @@ class InputPrometheusTypedDict(TypedDict):
     target_list: NotRequired[List[str]]
     r"""List of Prometheus targets to pull metrics from. Values can be in URL or host[:port] format. For example: http://localhost:9090/metrics, localhost:9090, or localhost. In cases where just host[:port] is specified, the endpoint will resolve to 'http://host[:port]/metrics'."""
     record_type: NotRequired[InputPrometheusRecordType]
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
     scrape_port: NotRequired[float]
-    r"""The port number in the metrics URL for discovered targets."""
+    r"""The port number in the metrics URL for discovered targets"""
     name_list: NotRequired[List[str]]
     r"""List of DNS names to resolve"""
     scrape_protocol: NotRequired[MetricsProtocol]
@@ -281,9 +283,9 @@ class InputPrometheusTypedDict(TypedDict):
     aws_secret: NotRequired[str]
     r"""Select or create a stored secret that references your access key and secret key"""
     use_public_ip: NotRequired[bool]
-    r"""Use public IP address for discovered targets. Set to false if the private IP address should be used."""
+    r"""Use public IP address for discovered targets. Disable to use the private IP address."""
     search_filter: NotRequired[List[InputPrometheusSearchFilterTypedDict]]
-    r"""EC2 Instance Search Filter"""
+    r"""Filter to apply when searching for EC2 instances"""
     aws_secret_key: NotRequired[str]
     region: NotRequired[str]
     r"""Region where the EC2 is located"""
@@ -354,7 +356,7 @@ class InputPrometheus(BaseModel):
     r"""Target discovery mechanism. Use static to manually enter a list of targets."""
 
     interval: Optional[float] = 15
-    r"""How often in minutes to scrape targets for metrics, 60 must be evenly divisible by the value or save will fail."""
+    r"""How often, in minutes, to scrape targets for metrics. Maximum of 60 minutes. 60 must be evenly divisible by the value you enter."""
 
     log_level: Annotated[
         Annotated[
@@ -362,13 +364,16 @@ class InputPrometheus(BaseModel):
         ],
         pydantic.Field(alias="logLevel"),
     ] = InputPrometheusLogLevel.INFO
-    r"""Collector runtime Log Level"""
+    r"""Collector runtime log level"""
 
     reject_unauthorized: Annotated[
         Optional[bool], pydantic.Field(alias="rejectUnauthorized")
     ] = True
     r"""Reject certificates that cannot be verified against a valid CA, such as self-signed certificates"""
 
+    timeout: Optional[float] = 0
+    r"""Time, in seconds, before aborting HTTP connection attempts; use 0 for no timeout"""
+
     keep_alive_time: Annotated[
         Optional[float], pydantic.Field(alias="keepAliveTime")
     ] = 30
@@ -416,10 +421,10 @@ class InputPrometheus(BaseModel):
         ],
         pydantic.Field(alias="recordType"),
     ] = InputPrometheusRecordType.SRV
-    r"""DNS Record type to resolve"""
+    r"""DNS record type to resolve"""
 
     scrape_port: Annotated[Optional[float], pydantic.Field(alias="scrapePort")] = 9090
-    r"""The port number in the metrics URL for discovered targets."""
+    r"""The port number in the metrics URL for discovered targets"""
 
     name_list: Annotated[Optional[List[str]], pydantic.Field(alias="nameList")] = None
     r"""List of DNS names to resolve"""
@@ -450,13 +455,13 @@ class InputPrometheus(BaseModel):
     r"""Select or create a stored secret that references your access key and secret key"""
 
     use_public_ip: Annotated[Optional[bool], pydantic.Field(alias="usePublicIp")] = True
-    r"""Use public IP address for discovered targets. Set to false if the private IP address should be used."""
+    r"""Use public IP address for discovered targets. Disable to use the private IP address."""
 
     search_filter: Annotated[
         Optional[List[InputPrometheusSearchFilter]],
         pydantic.Field(alias="searchFilter"),
     ] = None
-    r"""EC2 Instance Search Filter"""
+    r"""Filter to apply when searching for EC2 instances"""
 
     aws_secret_key: Annotated[Optional[str], pydantic.Field(alias="awsSecretKey")] = (
         None

cribl_control_plane/models/nodeprovidedinfo.py

@@ -33,6 +33,45 @@ class NodeProvidedInfoAws(BaseModel):
     tags: Optional[Dict[str, str]] = None
 
 
+class NodeProvidedInfoAzureTypedDict(TypedDict):
+    enabled: bool
+    hostname: NotRequired[str]
+    instance_id: NotRequired[str]
+    name: NotRequired[str]
+    region: NotRequired[str]
+    resource_group: NotRequired[str]
+    subscription_id: NotRequired[str]
+    tags: NotRequired[Dict[str, str]]
+    type: NotRequired[str]
+    zone: NotRequired[str]
+
+
+class NodeProvidedInfoAzure(BaseModel):
+    enabled: bool
+
+    hostname: Optional[str] = None
+
+    instance_id: Annotated[Optional[str], pydantic.Field(alias="instanceId")] = None
+
+    name: Optional[str] = None
+
+    region: Optional[str] = None
+
+    resource_group: Annotated[Optional[str], pydantic.Field(alias="resourceGroup")] = (
+        None
+    )
+
+    subscription_id: Annotated[
+        Optional[str], pydantic.Field(alias="subscriptionId")
+    ] = None
+
+    tags: Optional[Dict[str, str]] = None
+
+    type: Optional[str] = None
+
+    zone: Optional[str] = None
+
+
 class NodeProvidedInfoHostOsTypedDict(TypedDict):
     addresses: List[str]
     enabled: bool
@@ -130,6 +169,7 @@ class NodeProvidedInfoTypedDict(TypedDict):
     total_disk_space: float
     totalmem: float
     aws: NotRequired[NodeProvidedInfoAwsTypedDict]
+    azure: NotRequired[NodeProvidedInfoAzureTypedDict]
     conn_ip: NotRequired[str]
     host_os: NotRequired[NodeProvidedInfoHostOsTypedDict]
     is_saas_worker: NotRequired[bool]
@@ -165,6 +205,8 @@ class NodeProvidedInfo(BaseModel):
 
     aws: Optional[NodeProvidedInfoAws] = None
 
+    azure: Optional[NodeProvidedInfoAzure] = None
+
     conn_ip: Optional[str] = None
 
     host_os: Annotated[

cribl_control_plane/models/output.py

@@ -15,6 +15,10 @@ from .outputcloudwatch import OutputCloudwatch, OutputCloudwatchTypedDict
 from .outputconfluentcloud import OutputConfluentCloud, OutputConfluentCloudTypedDict
 from .outputcriblhttp import OutputCriblHTTP, OutputCriblHTTPTypedDict
 from .outputcribllake import OutputCriblLake, OutputCriblLakeTypedDict
+from .outputcriblsearchengine import (
+    OutputCriblSearchEngine,
+    OutputCriblSearchEngineTypedDict,
+)
 from .outputcribltcp import OutputCriblTCP, OutputCriblTCPTypedDict
 from .outputcrowdstrikenextgensiem import (
     OutputCrowdstrikeNextGenSiem,
@@ -114,30 +118,31 @@ OutputTypedDict = TypeAliasType(
         OutputHoneycombTypedDict,
         OutputSignalfxTypedDict,
         OutputWavefrontTypedDict,
-        OutputSumoLogicTypedDict,
+        OutputElasticCloudTypedDict,
         OutputCrowdstrikeNextGenSiemTypedDict,
-        OutputHumioHecTypedDict,
+        OutputSumoLogicTypedDict,
         OutputTcpjsonTypedDict,
-        OutputElasticCloudTypedDict,
+        OutputHumioHecTypedDict,
         OutputKinesisTypedDict,
         OutputConfluentCloudTypedDict,
+        OutputAzureLogsTypedDict,
         OutputKafkaTypedDict,
         OutputNewrelicEventsTypedDict,
-        OutputAzureLogsTypedDict,
         OutputSplunkLbTypedDict,
         OutputSqsTypedDict,
-        OutputNewrelicTypedDict,
         OutputFilesystemTypedDict,
         OutputSyslogTypedDict,
+        OutputNewrelicTypedDict,
         OutputXsiamTypedDict,
         OutputCriblHTTPTypedDict,
         OutputDatasetTypedDict,
+        OutputCriblSearchEngineTypedDict,
         OutputDynatraceHTTPTypedDict,
         OutputLokiTypedDict,
+        OutputSplunkHecTypedDict,
         OutputChronicleTypedDict,
-        OutputDynatraceOtlpTypedDict,
         OutputServiceNowTypedDict,
-        OutputSplunkHecTypedDict,
+        OutputDynatraceOtlpTypedDict,
         OutputCriblLakeTypedDict,
         OutputElasticTypedDict,
         OutputDatadogTypedDict,
@@ -147,16 +152,16 @@ OutputTypedDict = TypeAliasType(
         OutputSentinelOneAiSiemTypedDict,
         OutputMskTypedDict,
         OutputSentinelTypedDict,
-        OutputGoogleCloudStorageTypedDict,
         OutputInfluxdbTypedDict,
+        OutputGoogleCloudStorageTypedDict,
         OutputAzureBlobTypedDict,
         OutputCloudflareR2TypedDict,
         OutputMinioTypedDict,
         OutputOpenTelemetryTypedDict,
         OutputSecurityLakeTypedDict,
         OutputClickHouseTypedDict,
-        OutputDlS3TypedDict,
         OutputS3TypedDict,
+        OutputDlS3TypedDict,
         OutputWebhookTypedDict,
         OutputGoogleCloudLoggingTypedDict,
         OutputAzureDataExplorerTypedDict,
@@ -219,6 +224,7 @@ Output = Annotated[
         Annotated[OutputDataset, Tag("dataset")],
         Annotated[OutputCriblTCP, Tag("cribl_tcp")],
         Annotated[OutputCriblHTTP, Tag("cribl_http")],
+        Annotated[OutputCriblSearchEngine, Tag("cribl_search_engine")],
         Annotated[OutputHumioHec, Tag("humio_hec")],
         Annotated[OutputCrowdstrikeNextGenSiem, Tag("crowdstrike_next_gen_siem")],
         Annotated[OutputDlS3, Tag("dl_s3")],

cribl_control_plane/models/outputclickhouse.py

@@ -210,6 +210,32 @@ class OutputClickHouseTimeoutRetrySettings(BaseModel):
     r"""The maximum backoff interval, in milliseconds, Cribl Stream should apply. Default (and minimum) is 10,000 ms (10 seconds); maximum is 180,000 ms (180 seconds)."""
 
 
+class StatsDestinationTypedDict(TypedDict):
+    url: NotRequired[str]
+    database: NotRequired[str]
+    table_name: NotRequired[str]
+    auth_type: NotRequired[str]
+    username: NotRequired[str]
+    sql_username: NotRequired[str]
+    password: NotRequired[str]
+
+
+class StatsDestination(BaseModel):
+    url: Optional[str] = None
+
+    database: Optional[str] = None
+
+    table_name: Annotated[Optional[str], pydantic.Field(alias="tableName")] = None
+
+    auth_type: Annotated[Optional[str], pydantic.Field(alias="authType")] = None
+
+    username: Optional[str] = None
+
+    sql_username: Annotated[Optional[str], pydantic.Field(alias="sqlUsername")] = None
+
+    password: Optional[str] = None
+
+
 class OutputClickHouseBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -369,6 +395,7 @@ class OutputClickHouseTypedDict(TypedDict):
     r"""Honor any Retry-After header that specifies a delay (in seconds) no longer than 180 seconds after the retry request. @{product} limits the delay to 180 seconds, even if the Retry-After header specifies a longer delay. When enabled, takes precedence over user-configured retry options. When disabled, all Retry-After headers are ignored."""
     dump_format_errors_to_disk: NotRequired[bool]
     r"""Log the most recent event that fails to match the table schema"""
+    stats_destination: NotRequired[StatsDestinationTypedDict]
     on_backpressure: NotRequired[OutputClickHouseBackpressureBehavior]
     r"""How to handle events when all receivers are exerting backpressure"""
     description: NotRequired[str]
@@ -563,6 +590,10 @@ class OutputClickHouse(BaseModel):
     ] = False
     r"""Log the most recent event that fails to match the table schema"""
 
+    stats_destination: Annotated[
+        Optional[StatsDestination], pydantic.Field(alias="statsDestination")
+    ] = None
+
     on_backpressure: Annotated[
         Annotated[
             Optional[OutputClickHouseBackpressureBehavior],

cribl_control_plane/models/outputcriblhttp.py

@@ -323,6 +323,8 @@ class OutputCriblHTTPTypedDict(TypedDict):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
     safe_headers: NotRequired[List[str]]
     r"""List of headers that are safe to log in plain text"""
+    throttle_rate_per_sec: NotRequired[str]
+    r"""Rate (in bytes per second) to throttle while writing to an output. Accepts values with multiple-byte units, such as KB, MB, and GB. (Example: 42 MB) Default value of 0 specifies no throttling."""
     response_retry_settings: NotRequired[
         List[OutputCriblHTTPResponseRetrySettingTypedDict]
     ]
@@ -460,6 +462,11 @@ class OutputCriblHTTP(BaseModel):
     ] = None
     r"""List of headers that are safe to log in plain text"""
 
+    throttle_rate_per_sec: Annotated[
+        Optional[str], pydantic.Field(alias="throttleRatePerSec")
+    ] = "0"
+    r"""Rate (in bytes per second) to throttle while writing to an output. Accepts values with multiple-byte units, such as KB, MB, and GB. (Example: 42 MB) Default value of 0 specifies no throttling."""
+
     response_retry_settings: Annotated[
         Optional[List[OutputCriblHTTPResponseRetrySetting]],
         pydantic.Field(alias="responseRetrySettings"),