cribl-control-plane 0.0.13__py3-none-any.whl

cribl_control_plane/models/inputedgeprometheus.py

@@ -0,0 +1,551 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane import utils
+from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class InputEdgePrometheusType(str, Enum, metaclass=utils.OpenEnumMeta):
+    EDGE_PROMETHEUS = "edge_prometheus"
+
+
+class InputEdgePrometheusConnectionTypedDict(TypedDict):
+    output: str
+    pipeline: NotRequired[str]
+
+
+class InputEdgePrometheusConnection(BaseModel):
+    output: str
+
+    pipeline: Optional[str] = None
+
+
+class InputEdgePrometheusMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
+
+    SMART = "smart"
+    ALWAYS = "always"
+
+
+class InputEdgePrometheusPqCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Codec to use to compress the persisted data"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+class InputEdgePrometheusPqTypedDict(TypedDict):
+    mode: NotRequired[InputEdgePrometheusMode]
+    r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
+    max_buffer_size: NotRequired[float]
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+    commit_frequency: NotRequired[float]
+    r"""The number of events to send downstream before committing that Stream has read them"""
+    max_file_size: NotRequired[str]
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+    max_size: NotRequired[str]
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+    path: NotRequired[str]
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
+    compress: NotRequired[InputEdgePrometheusPqCompression]
+    r"""Codec to use to compress the persisted data"""
+
+
+class InputEdgePrometheusPq(BaseModel):
+    mode: Annotated[
+        Optional[InputEdgePrometheusMode], PlainValidator(validate_open_enum(False))
+    ] = InputEdgePrometheusMode.ALWAYS
+    r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
+
+    max_buffer_size: Annotated[
+        Optional[float], pydantic.Field(alias="maxBufferSize")
+    ] = 1000
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+
+    commit_frequency: Annotated[
+        Optional[float], pydantic.Field(alias="commitFrequency")
+    ] = 42
+    r"""The number of events to send downstream before committing that Stream has read them"""
+
+    max_file_size: Annotated[Optional[str], pydantic.Field(alias="maxFileSize")] = (
+        "1 MB"
+    )
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+
+    max_size: Annotated[Optional[str], pydantic.Field(alias="maxSize")] = "5GB"
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+
+    path: Optional[str] = "$CRIBL_HOME/state/queues"
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
+
+    compress: Annotated[
+        Optional[InputEdgePrometheusPqCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputEdgePrometheusPqCompression.NONE
+    r"""Codec to use to compress the persisted data"""
+
+
+class InputEdgePrometheusDiscoveryType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Target discovery mechanism. Use static to manually enter a list of targets."""
+
+    STATIC = "static"
+    DNS = "dns"
+    EC2 = "ec2"
+    K8S_NODE = "k8s-node"
+    K8S_PODS = "k8s-pods"
+
+
+class InputEdgePrometheusPersistenceCompression(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Data compression format. Default is gzip."""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+class InputEdgePrometheusDiskSpoolingTypedDict(TypedDict):
+    enable: NotRequired[bool]
+    r"""Spool events on disk for Cribl Edge and Search. Default is disabled."""
+    time_window: NotRequired[str]
+    r"""Time period for grouping spooled events. Default is 10m."""
+    max_data_size: NotRequired[str]
+    r"""Maximum disk space that can be consumed before older buckets are deleted. Examples: 420MB, 4GB. Default is 1GB."""
+    max_data_time: NotRequired[str]
+    r"""Maximum amount of time to retain data before older buckets are deleted. Examples: 2h, 4d. Default is 24h."""
+    compress: NotRequired[InputEdgePrometheusPersistenceCompression]
+    r"""Data compression format. Default is gzip."""
+
+
+class InputEdgePrometheusDiskSpooling(BaseModel):
+    enable: Optional[bool] = False
+    r"""Spool events on disk for Cribl Edge and Search. Default is disabled."""
+
+    time_window: Annotated[Optional[str], pydantic.Field(alias="timeWindow")] = "10m"
+    r"""Time period for grouping spooled events. Default is 10m."""
+
+    max_data_size: Annotated[Optional[str], pydantic.Field(alias="maxDataSize")] = "1GB"
+    r"""Maximum disk space that can be consumed before older buckets are deleted. Examples: 420MB, 4GB. Default is 1GB."""
+
+    max_data_time: Annotated[Optional[str], pydantic.Field(alias="maxDataTime")] = "24h"
+    r"""Maximum amount of time to retain data before older buckets are deleted. Examples: 2h, 4d. Default is 24h."""
+
+    compress: Annotated[
+        Optional[InputEdgePrometheusPersistenceCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputEdgePrometheusPersistenceCompression.GZIP
+    r"""Data compression format. Default is gzip."""
+
+
+class InputEdgePrometheusMetadatumTypedDict(TypedDict):
+    name: str
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputEdgePrometheusMetadatum(BaseModel):
+    name: str
+
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputEdgePrometheusAuthTypeAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Enter credentials directly, or select a stored secret"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+    KUBERNETES = "kubernetes"
+
+
+class TargetProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Protocol to use when collecting metrics"""
+
+    HTTP = "http"
+    HTTPS = "https"
+
+
+class TargetTypedDict(TypedDict):
+    host: str
+    r"""Name of host from which to pull metrics."""
+    protocol: NotRequired[TargetProtocol]
+    r"""Protocol to use when collecting metrics"""
+    port: NotRequired[float]
+    r"""The port number in the metrics URL for discovered targets."""
+    path: NotRequired[str]
+    r"""Path to use when collecting metrics from discovered targets"""
+
+
+class Target(BaseModel):
+    host: str
+    r"""Name of host from which to pull metrics."""
+
+    protocol: Annotated[
+        Optional[TargetProtocol], PlainValidator(validate_open_enum(False))
+    ] = TargetProtocol.HTTP
+    r"""Protocol to use when collecting metrics"""
+
+    port: Optional[float] = 9090
+    r"""The port number in the metrics URL for discovered targets."""
+
+    path: Optional[str] = "/metrics"
+    r"""Path to use when collecting metrics from discovered targets"""
+
+
+class InputEdgePrometheusRecordType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""DNS Record type to resolve"""
+
+    SRV = "SRV"
+    A = "A"
+    AAAA = "AAAA"
+
+
+class ScrapeProtocolProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Protocol to use when collecting metrics"""
+
+    HTTP = "http"
+    HTTPS = "https"
+
+
+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"""
+    values: List[str]
+    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+
+
+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"""
+
+    values: Annotated[List[str], pydantic.Field(alias="Values")]
+    r"""Search Filter Values, if empty only \"running\" EC2 instances will be returned"""
+
+
+class InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    AUTO = "auto"
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class InputEdgePrometheusSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Signature version to use for signing EC2 requests"""
+
+    V2 = "v2"
+    V4 = "v4"
+
+
+class PodFilterTypedDict(TypedDict):
+    filter_: str
+    r"""JavaScript expression applied to pods objects. Return 'true' to include it."""
+    description: NotRequired[str]
+    r"""Optional description of this rule's purpose"""
+
+
+class PodFilter(BaseModel):
+    filter_: Annotated[str, pydantic.Field(alias="filter")]
+    r"""JavaScript expression applied to pods objects. Return 'true' to include it."""
+
+    description: Optional[str] = None
+    r"""Optional description of this rule's purpose"""
+
+
+class InputEdgePrometheusTypedDict(TypedDict):
+    type: InputEdgePrometheusType
+    id: NotRequired[str]
+    r"""Unique ID for this input"""
+    disabled: NotRequired[bool]
+    pipeline: NotRequired[str]
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+    send_to_routes: NotRequired[bool]
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+    environment: NotRequired[str]
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+    pq_enabled: NotRequired[bool]
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+    streamtags: NotRequired[List[str]]
+    r"""Tags for filtering and grouping in @{product}"""
+    connections: NotRequired[List[InputEdgePrometheusConnectionTypedDict]]
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+    pq: NotRequired[InputEdgePrometheusPqTypedDict]
+    dimension_list: NotRequired[List[str]]
+    r"""Other dimensions to include in events"""
+    discovery_type: NotRequired[InputEdgePrometheusDiscoveryType]
+    r"""Target discovery mechanism. Use static to manually enter a list of targets."""
+    interval: NotRequired[float]
+    r"""How often in seconds to scrape targets for metrics."""
+    timeout: NotRequired[float]
+    r"""Timeout, in milliseconds, before aborting HTTP connection attempts; 1-60000 or 0 to disable"""
+    persistence: NotRequired[InputEdgePrometheusDiskSpoolingTypedDict]
+    metadata: NotRequired[List[InputEdgePrometheusMetadatumTypedDict]]
+    r"""Fields to add to events from this input"""
+    auth_type: NotRequired[InputEdgePrometheusAuthTypeAuthenticationMethod]
+    r"""Enter credentials directly, or select a stored secret"""
+    description: NotRequired[str]
+    targets: NotRequired[List[TargetTypedDict]]
+    name_list: NotRequired[List[str]]
+    r"""List of DNS names to resolve"""
+    record_type: NotRequired[InputEdgePrometheusRecordType]
+    r"""DNS Record type to resolve"""
+    scrape_protocol: NotRequired[ScrapeProtocolProtocol]
+    r"""Protocol to use when collecting metrics"""
+    scrape_path: NotRequired[str]
+    r"""Path to use when collecting metrics from discovered targets"""
+    use_public_ip: NotRequired[bool]
+    r"""Use public IP address for discovered targets. Set to false if the private IP address should be used."""
+    scrape_port: NotRequired[float]
+    r"""The port number in the metrics URL for discovered targets."""
+    search_filter: NotRequired[List[InputEdgePrometheusSearchFilterTypedDict]]
+    r"""EC2 Instance Search Filter"""
+    aws_authentication_method: NotRequired[
+        InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod
+    ]
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+    aws_secret_key: NotRequired[str]
+    region: NotRequired[str]
+    r"""Region where the EC2 is located"""
+    endpoint: NotRequired[str]
+    r"""EC2 service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to EC2-compatible endpoint."""
+    signature_version: NotRequired[InputEdgePrometheusSignatureVersion]
+    r"""Signature version to use for signing EC2 requests"""
+    reuse_connections: NotRequired[bool]
+    r"""Reuse connections between requests, which can improve performance"""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates that cannot be verified against a valid CA, such as self-signed certificates"""
+    enable_assume_role: NotRequired[bool]
+    r"""Use Assume Role credentials to access EC2"""
+    assume_role_arn: NotRequired[str]
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+    assume_role_external_id: NotRequired[str]
+    r"""External ID to use when assuming role"""
+    duration_seconds: NotRequired[float]
+    r"""Duration of the assumed role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+    scrape_protocol_expr: NotRequired[str]
+    r"""Protocol to use when collecting metrics"""
+    scrape_port_expr: NotRequired[str]
+    r"""The port number in the metrics URL for discovered targets."""
+    scrape_path_expr: NotRequired[str]
+    r"""Path to use when collecting metrics from discovered targets"""
+    pod_filter: NotRequired[List[PodFilterTypedDict]]
+    r"""Add rules to decide which pods to discover for metrics.
+    Pods are searched if no rules are given or of all the rules'
+    expressions evaluate to true.
+
+    """
+    username: NotRequired[str]
+    r"""Username for Prometheus Basic authentication"""
+    password: NotRequired[str]
+    r"""Password for Prometheus Basic authentication"""
+    credentials_secret: NotRequired[str]
+    r"""Select or create a secret that references your credentials"""
+
+
+class InputEdgePrometheus(BaseModel):
+    type: Annotated[InputEdgePrometheusType, PlainValidator(validate_open_enum(False))]
+
+    id: Optional[str] = None
+    r"""Unique ID for this input"""
+
+    disabled: Optional[bool] = False
+
+    pipeline: Optional[str] = None
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+
+    send_to_routes: Annotated[Optional[bool], pydantic.Field(alias="sendToRoutes")] = (
+        True
+    )
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+
+    environment: Optional[str] = None
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+
+    pq_enabled: Annotated[Optional[bool], pydantic.Field(alias="pqEnabled")] = False
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+
+    streamtags: Optional[List[str]] = None
+    r"""Tags for filtering and grouping in @{product}"""
+
+    connections: Optional[List[InputEdgePrometheusConnection]] = None
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+
+    pq: Optional[InputEdgePrometheusPq] = None
+
+    dimension_list: Annotated[
+        Optional[List[str]], pydantic.Field(alias="dimensionList")
+    ] = None
+    r"""Other dimensions to include in events"""
+
+    discovery_type: Annotated[
+        Annotated[
+            Optional[InputEdgePrometheusDiscoveryType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="discoveryType"),
+    ] = InputEdgePrometheusDiscoveryType.STATIC
+    r"""Target discovery mechanism. Use static to manually enter a list of targets."""
+
+    interval: Optional[float] = 15
+    r"""How often in seconds to scrape targets for metrics."""
+
+    timeout: Optional[float] = 5000
+    r"""Timeout, in milliseconds, before aborting HTTP connection attempts; 1-60000 or 0 to disable"""
+
+    persistence: Optional[InputEdgePrometheusDiskSpooling] = None
+
+    metadata: Optional[List[InputEdgePrometheusMetadatum]] = None
+    r"""Fields to add to events from this input"""
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputEdgePrometheusAuthTypeAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputEdgePrometheusAuthTypeAuthenticationMethod.MANUAL
+    r"""Enter credentials directly, or select a stored secret"""
+
+    description: Optional[str] = None
+
+    targets: Optional[List[Target]] = None
+
+    name_list: Annotated[Optional[List[str]], pydantic.Field(alias="nameList")] = None
+    r"""List of DNS names to resolve"""
+
+    record_type: Annotated[
+        Annotated[
+            Optional[InputEdgePrometheusRecordType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="recordType"),
+    ] = InputEdgePrometheusRecordType.SRV
+    r"""DNS Record type to resolve"""
+
+    scrape_protocol: Annotated[
+        Annotated[
+            Optional[ScrapeProtocolProtocol], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="scrapeProtocol"),
+    ] = ScrapeProtocolProtocol.HTTP
+    r"""Protocol to use when collecting metrics"""
+
+    scrape_path: Annotated[Optional[str], pydantic.Field(alias="scrapePath")] = (
+        "/metrics"
+    )
+    r"""Path to use when collecting metrics from discovered targets"""
+
+    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."""
+
+    scrape_port: Annotated[Optional[float], pydantic.Field(alias="scrapePort")] = 9090
+    r"""The port number in the metrics URL for discovered targets."""
+
+    search_filter: Annotated[
+        Optional[List[InputEdgePrometheusSearchFilter]],
+        pydantic.Field(alias="searchFilter"),
+    ] = None
+    r"""EC2 Instance Search Filter"""
+
+    aws_authentication_method: Annotated[
+        Annotated[
+            Optional[InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="awsAuthenticationMethod"),
+    ] = InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod.AUTO
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    aws_secret_key: Annotated[Optional[str], pydantic.Field(alias="awsSecretKey")] = (
+        None
+    )
+
+    region: Optional[str] = None
+    r"""Region where the EC2 is located"""
+
+    endpoint: Optional[str] = None
+    r"""EC2 service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to EC2-compatible endpoint."""
+
+    signature_version: Annotated[
+        Annotated[
+            Optional[InputEdgePrometheusSignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
+    ] = InputEdgePrometheusSignatureVersion.V4
+    r"""Signature version to use for signing EC2 requests"""
+
+    reuse_connections: Annotated[
+        Optional[bool], pydantic.Field(alias="reuseConnections")
+    ] = True
+    r"""Reuse connections between requests, which can improve performance"""
+
+    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"""
+
+    enable_assume_role: Annotated[
+        Optional[bool], pydantic.Field(alias="enableAssumeRole")
+    ] = False
+    r"""Use Assume Role credentials to access EC2"""
+
+    assume_role_arn: Annotated[Optional[str], pydantic.Field(alias="assumeRoleArn")] = (
+        None
+    )
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+
+    assume_role_external_id: Annotated[
+        Optional[str], pydantic.Field(alias="assumeRoleExternalId")
+    ] = None
+    r"""External ID to use when assuming role"""
+
+    duration_seconds: Annotated[
+        Optional[float], pydantic.Field(alias="durationSeconds")
+    ] = 3600
+    r"""Duration of the assumed role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+
+    scrape_protocol_expr: Annotated[
+        Optional[str], pydantic.Field(alias="scrapeProtocolExpr")
+    ] = "metadata.annotations['prometheus.io/scheme'] || 'http'"
+    r"""Protocol to use when collecting metrics"""
+
+    scrape_port_expr: Annotated[
+        Optional[str], pydantic.Field(alias="scrapePortExpr")
+    ] = "metadata.annotations['prometheus.io/port'] || 9090"
+    r"""The port number in the metrics URL for discovered targets."""
+
+    scrape_path_expr: Annotated[
+        Optional[str], pydantic.Field(alias="scrapePathExpr")
+    ] = "metadata.annotations['prometheus.io/path'] || '/metrics'"
+    r"""Path to use when collecting metrics from discovered targets"""
+
+    pod_filter: Annotated[
+        Optional[List[PodFilter]], pydantic.Field(alias="podFilter")
+    ] = None
+    r"""Add rules to decide which pods to discover for metrics.
+    Pods are searched if no rules are given or of all the rules'
+    expressions evaluate to true.
+
+    """
+
+    username: Optional[str] = None
+    r"""Username for Prometheus Basic authentication"""
+
+    password: Optional[str] = None
+    r"""Password for Prometheus Basic authentication"""
+
+    credentials_secret: Annotated[
+        Optional[str], pydantic.Field(alias="credentialsSecret")
+    ] = None
+    r"""Select or create a secret that references your credentials"""