cribl-control-plane 0.0.39__py3-none-any.whl → 0.4.0b23__py3-none-any.whl

cribl_control_plane/models/outputgooglecloudlogging.py

@@ -1,9 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from cribl_control_plane import models, 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 import field_serializer
+from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -12,17 +16,23 @@ class OutputGoogleCloudLoggingType(str, Enum):
     GOOGLE_CLOUD_LOGGING = "google_cloud_logging"
 
 
-class LogLocationType(str, Enum):
+class LogLocationType(str, Enum, metaclass=utils.OpenEnumMeta):
+    # Project
     PROJECT = "project"
+    # Organization
     ORGANIZATION = "organization"
+    # Billing Account
     BILLING_ACCOUNT = "billingAccount"
+    # Folder
     FOLDER = "folder"
 
 
-class PayloadFormat(str, Enum):
+class PayloadFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format to use when sending payload. Defaults to Text."""
 
+    # Text
     TEXT = "text"
+    # JSON
     JSON = "json"
 
 
@@ -56,44 +66,63 @@ class ResourceTypeLabel(BaseModel):
     r"""JavaScript expression to compute the label's value."""
 
 
-class OutputGoogleCloudLoggingGoogleAuthenticationMethod(str, Enum):
+class OutputGoogleCloudLoggingGoogleAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
 
+    # Auto
     AUTO = "auto"
+    # Manual
     MANUAL = "manual"
+    # Secret
     SECRET = "secret"
 
 
-class OutputGoogleCloudLoggingBackpressureBehavior(str, Enum):
+class OutputGoogleCloudLoggingBackpressureBehavior(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""How to handle events when all receivers are exerting backpressure"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
+    # Persistent Queue
     QUEUE = "queue"
 
 
-class OutputGoogleCloudLoggingCompression(str, Enum):
+class OutputGoogleCloudLoggingMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    # Error
+    ERROR = "error"
+    # Backpressure
+    ALWAYS = "always"
+    # Always On
+    BACKPRESSURE = "backpressure"
+
+
+class OutputGoogleCloudLoggingCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
-class OutputGoogleCloudLoggingQueueFullBehavior(str, Enum):
+class OutputGoogleCloudLoggingQueueFullBehavior(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
+    # Block
     BLOCK = "block"
+    # Drop new data
     DROP = "drop"
 
 
-class OutputGoogleCloudLoggingMode(str, Enum):
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    ERROR = "error"
-    BACKPRESSURE = "backpressure"
-    ALWAYS = "always"
-
-
 class OutputGoogleCloudLoggingPqControlsTypedDict(TypedDict):
     pass
 
@@ -106,9 +135,9 @@ class OutputGoogleCloudLoggingTypedDict(TypedDict):
     type: OutputGoogleCloudLoggingType
     log_location_type: LogLocationType
     log_name_expression: str
-    r"""JavaScript expression to compute the value of the log name."""
+    r"""JavaScript expression to compute the value of the log name. If Validate and correct log name is enabled, invalid characters (characters other than alphanumerics, forward-slashes, underscores, hyphens, and periods) will be replaced with an underscore."""
     log_location_expression: str
-    r"""JavaScript expression to compute the value of the folder ID with which log entries should be associated."""
+    r"""JavaScript expression to compute the value of the folder ID with which log entries should be associated. If Validate and correct log name is enabled, invalid characters (characters other than alphanumerics, forward-slashes, underscores, hyphens, and periods) will be replaced with an underscore."""
     id: NotRequired[str]
     r"""Unique ID for this output"""
     pipeline: NotRequired[str]
@@ -119,6 +148,7 @@ class OutputGoogleCloudLoggingTypedDict(TypedDict):
     r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
     streamtags: NotRequired[List[str]]
     r"""Tags for filtering and grouping in @{product}"""
+    sanitize_log_names: NotRequired[bool]
     payload_format: NotRequired[PayloadFormat]
     r"""Format to use when sending payload. Defaults to Text."""
     log_labels: NotRequired[List[LogLabelTypedDict]]
@@ -214,6 +244,16 @@ class OutputGoogleCloudLoggingTypedDict(TypedDict):
     description: NotRequired[str]
     payload_expression: NotRequired[str]
     r"""JavaScript expression to compute the value of the payload. Must evaluate to a JavaScript object value. If an invalid value is encountered it will result in the default value instead. Defaults to the entire event."""
+    pq_strict_ordering: NotRequired[bool]
+    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
+    pq_rate_per_sec: NotRequired[float]
+    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
+    pq_mode: NotRequired[OutputGoogleCloudLoggingMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+    pq_max_buffer_size: NotRequired[float]
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+    pq_max_backpressure_sec: NotRequired[float]
+    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -224,8 +264,6 @@ class OutputGoogleCloudLoggingTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputGoogleCloudLoggingQueueFullBehavior]
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
-    pq_mode: NotRequired[OutputGoogleCloudLoggingMode]
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
     pq_controls: NotRequired[OutputGoogleCloudLoggingPqControlsTypedDict]
 
 
@@ -233,16 +271,17 @@ class OutputGoogleCloudLogging(BaseModel):
     type: OutputGoogleCloudLoggingType
 
     log_location_type: Annotated[
-        LogLocationType, pydantic.Field(alias="logLocationType")
+        Annotated[LogLocationType, PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="logLocationType"),
     ]
 
     log_name_expression: Annotated[str, pydantic.Field(alias="logNameExpression")]
-    r"""JavaScript expression to compute the value of the log name."""
+    r"""JavaScript expression to compute the value of the log name. If Validate and correct log name is enabled, invalid characters (characters other than alphanumerics, forward-slashes, underscores, hyphens, and periods) will be replaced with an underscore."""
 
     log_location_expression: Annotated[
         str, pydantic.Field(alias="logLocationExpression")
     ]
-    r"""JavaScript expression to compute the value of the folder ID with which log entries should be associated."""
+    r"""JavaScript expression to compute the value of the folder ID with which log entries should be associated. If Validate and correct log name is enabled, invalid characters (characters other than alphanumerics, forward-slashes, underscores, hyphens, and periods) will be replaced with an underscore."""
 
     id: Optional[str] = None
     r"""Unique ID for this output"""
@@ -261,8 +300,13 @@ class OutputGoogleCloudLogging(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
+    sanitize_log_names: Annotated[
+        Optional[bool], pydantic.Field(alias="sanitizeLogNames")
+    ] = False
+
     payload_format: Annotated[
-        Optional[PayloadFormat], pydantic.Field(alias="payloadFormat")
+        Annotated[Optional[PayloadFormat], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="payloadFormat"),
     ] = PayloadFormat.TEXT
     r"""Format to use when sending payload. Defaults to Text."""
 
@@ -292,7 +336,10 @@ class OutputGoogleCloudLogging(BaseModel):
     r"""JavaScript expression to compute the value of the insert ID field."""
 
     google_auth_method: Annotated[
-        Optional[OutputGoogleCloudLoggingGoogleAuthenticationMethod],
+        Annotated[
+            Optional[OutputGoogleCloudLoggingGoogleAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="googleAuthMethod"),
     ] = OutputGoogleCloudLoggingGoogleAuthenticationMethod.MANUAL
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
@@ -475,7 +522,10 @@ class OutputGoogleCloudLogging(BaseModel):
     r"""A JavaScript expression that evaluates to the the sampling decision of the span associated with the log entry. See the [documentation](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry) for details."""
 
     on_backpressure: Annotated[
-        Optional[OutputGoogleCloudLoggingBackpressureBehavior],
+        Annotated[
+            Optional[OutputGoogleCloudLoggingBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputGoogleCloudLoggingBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -492,6 +542,35 @@ class OutputGoogleCloudLogging(BaseModel):
     ] = None
     r"""JavaScript expression to compute the value of the payload. Must evaluate to a JavaScript object value. If an invalid value is encountered it will result in the default value instead. Defaults to the entire event."""
 
+    pq_strict_ordering: Annotated[
+        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
+    ] = True
+    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
+
+    pq_rate_per_sec: Annotated[
+        Optional[float], pydantic.Field(alias="pqRatePerSec")
+    ] = 0
+    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
+
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputGoogleCloudLoggingMode],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputGoogleCloudLoggingMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    pq_max_buffer_size: Annotated[
+        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
+    ] = 42
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+
+    pq_max_backpressure_sec: Annotated[
+        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
+    ] = 30
+    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
+
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -506,22 +585,86 @@ class OutputGoogleCloudLogging(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Optional[OutputGoogleCloudLoggingCompression],
+        Annotated[
+            Optional[OutputGoogleCloudLoggingCompression],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqCompress"),
     ] = OutputGoogleCloudLoggingCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputGoogleCloudLoggingQueueFullBehavior],
+        Annotated[
+            Optional[OutputGoogleCloudLoggingQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputGoogleCloudLoggingQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
-    pq_mode: Annotated[
-        Optional[OutputGoogleCloudLoggingMode], pydantic.Field(alias="pqMode")
-    ] = OutputGoogleCloudLoggingMode.ERROR
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
     pq_controls: Annotated[
         Optional[OutputGoogleCloudLoggingPqControls], pydantic.Field(alias="pqControls")
     ] = None
+
+    @field_serializer("log_location_type")
+    def serialize_log_location_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.LogLocationType(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("payload_format")
+    def serialize_payload_format(self, value):
+        if isinstance(value, str):
+            try:
+                return models.PayloadFormat(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("google_auth_method")
+    def serialize_google_auth_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputGoogleCloudLoggingGoogleAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_backpressure")
+    def serialize_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputGoogleCloudLoggingBackpressureBehavior(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_mode")
+    def serialize_pq_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputGoogleCloudLoggingMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_compress")
+    def serialize_pq_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputGoogleCloudLoggingCompression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_on_backpressure")
+    def serialize_pq_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputGoogleCloudLoggingQueueFullBehavior(value)
+            except ValueError:
+                return value
+        return value