diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c554255f13..b5268fe7d7 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -48499,6 +48499,118 @@ components: type: string x-enum-varnames: - ADD_HOSTNAME + ObservabilityPipelineAddMetricTagsProcessor: + description: |- + The `add_metric_tags` processor adds static tags to metrics. + + **Supported pipeline types:** metrics + properties: + display_name: + $ref: "#/components/schemas/ObservabilityPipelineComponentDisplayName" + enabled: + description: Indicates whether the processor is enabled. + example: true + type: boolean + id: + description: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the `input` to downstream components). + example: "add-metric-tags-processor" + type: string + include: + description: A Datadog search query used to determine which metrics this processor targets. + example: "*" + type: string + tags: + description: A list of static tags (key-value pairs) added to each metric processed by this component. + items: + $ref: "#/components/schemas/ObservabilityPipelineFieldValue" + maxItems: 15 + type: array + type: + $ref: "#/components/schemas/ObservabilityPipelineAddMetricTagsProcessorType" + required: + - id + - type + - include + - tags + - enabled + type: object + x-pipeline-types: [metrics] + ObservabilityPipelineAddMetricTagsProcessorType: + default: add_metric_tags + description: The processor type. The value should always be `add_metric_tags`. + enum: [add_metric_tags] + example: add_metric_tags + type: string + x-enum-varnames: + - ADD_METRIC_TAGS + ObservabilityPipelineAggregateProcessor: + description: |- + The `aggregate` processor combines metrics that share the same name and tags into a single metric over a configurable interval. + + **Supported pipeline types:** metrics + properties: + display_name: + $ref: "#/components/schemas/ObservabilityPipelineComponentDisplayName" + enabled: + description: Indicates whether the processor is enabled. + example: true + type: boolean + id: + description: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the `input` to downstream components). + example: "aggregate-processor" + type: string + include: + description: A Datadog search query used to determine which metrics this processor targets. + example: "*" + type: string + interval_secs: + description: The interval, in seconds, over which metrics are aggregated. + example: 10 + format: int64 + maximum: 60 + minimum: 1 + type: integer + mode: + $ref: "#/components/schemas/ObservabilityPipelineAggregateProcessorMode" + type: + $ref: "#/components/schemas/ObservabilityPipelineAggregateProcessorType" + required: + - id + - type + - include + - interval_secs + - mode + - enabled + type: object + x-pipeline-types: [metrics] + ObservabilityPipelineAggregateProcessorMode: + description: The aggregation mode applied to metrics that share the same name and tags within the interval. + enum: + - auto + - sum + - latest + - count + - max + - min + - mean + example: auto + type: string + x-enum-varnames: + - AUTO + - SUM + - LATEST + - COUNT + - MAX + - MIN + - MEAN + ObservabilityPipelineAggregateProcessorType: + default: aggregate + description: The processor type. The value should always be `aggregate`. + enum: [aggregate] + example: aggregate + type: string + x-enum-varnames: + - AGGREGATE ObservabilityPipelineAmazonDataFirehoseSource: description: |- The `amazon_data_firehose` source ingests logs from AWS Data Firehose. @@ -49210,7 +49322,11 @@ components: - $ref: "#/components/schemas/ObservabilityPipelineSensitiveDataScannerProcessor" - $ref: "#/components/schemas/ObservabilityPipelineSplitArrayProcessor" - $ref: "#/components/schemas/ObservabilityPipelineThrottleProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineAddMetricTagsProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineAggregateProcessor" - $ref: "#/components/schemas/ObservabilityPipelineMetricTagsProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineRenameMetricTagsProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessor" ObservabilityPipelineConfigSourceItem: description: "A data source for the pipeline." oneOf: @@ -52174,6 +52290,65 @@ components: type: string x-enum-varnames: - RENAME_FIELDS + ObservabilityPipelineRenameMetricTagsProcessor: + description: |- + The `rename_metric_tags` processor changes the keys of tags on metrics. + + **Supported pipeline types:** metrics + properties: + display_name: + $ref: "#/components/schemas/ObservabilityPipelineComponentDisplayName" + enabled: + description: Indicates whether the processor is enabled. + example: true + type: boolean + id: + description: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the `input` to downstream components). + example: "rename-metric-tags-processor" + type: string + include: + description: A Datadog search query used to determine which metrics this processor targets. + example: "*" + type: string + tags: + description: A list of rename rules specifying which tag keys to rename on each metric. + items: + $ref: "#/components/schemas/ObservabilityPipelineRenameMetricTagsProcessorTag" + maxItems: 15 + type: array + type: + $ref: "#/components/schemas/ObservabilityPipelineRenameMetricTagsProcessorType" + required: + - id + - type + - include + - tags + - enabled + type: object + x-pipeline-types: [metrics] + ObservabilityPipelineRenameMetricTagsProcessorTag: + description: Defines how to rename a tag on metric events. + properties: + rename_to: + description: The new tag key to assign in place of the original. + example: "destination_tag" + type: string + tag: + description: The original tag key on the metric event. + example: "source_tag" + type: string + required: + - tag + - rename_to + type: object + ObservabilityPipelineRenameMetricTagsProcessorType: + default: rename_metric_tags + description: The processor type. The value should always be `rename_metric_tags`. + enum: [rename_metric_tags] + example: rename_metric_tags + type: string + x-enum-varnames: + - RENAME_METRIC_TAGS ObservabilityPipelineRsyslogDestination: description: |- The `rsyslog` destination forwards logs to an external `rsyslog` server over TCP or UDP using the syslog protocol. @@ -53365,6 +53540,141 @@ components: x-enum-varnames: - TCP - UDP + ObservabilityPipelineTagCardinalityLimitProcessor: + description: |- + The `tag_cardinality_limit` processor caps the number of distinct tag value combinations on metrics, dropping tags or events once the limit is exceeded. + + **Supported pipeline types:** metrics + properties: + display_name: + $ref: "#/components/schemas/ObservabilityPipelineComponentDisplayName" + enabled: + description: Indicates whether the processor is enabled. + example: true + type: boolean + id: + description: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the `input` to downstream components). + example: "tag-cardinality-limit-processor" + type: string + include: + description: A Datadog search query used to determine which metrics this processor targets. + example: "*" + type: string + limit_exceeded_action: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorAction" + per_metric_limits: + description: A list of per-metric cardinality overrides that take precedence over the default `value_limit`. + items: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit" + maxItems: 100 + type: array + type: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorType" + value_limit: + description: The default maximum number of distinct tag value combinations allowed per metric. + example: 10000 + format: int64 + maximum: 1000000 + minimum: 0 + type: integer + required: + - id + - type + - include + - limit_exceeded_action + - value_limit + - enabled + type: object + x-pipeline-types: [metrics] + ObservabilityPipelineTagCardinalityLimitProcessorAction: + description: The action to take when the cardinality limit is exceeded. + enum: + - drop_tag + - drop_event + example: drop_tag + type: string + x-enum-varnames: + - DROP_TAG + - DROP_EVENT + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit: + description: A cardinality override applied to a specific metric. + properties: + limit_exceeded_action: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorAction" + metric_name: + description: The name of the metric this override applies to. + example: "system.cpu.user" + type: string + mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode" + per_tag_limits: + description: A list of per-tag cardinality overrides that apply within this metric. + items: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit" + maxItems: 50 + type: array + value_limit: + description: The maximum number of distinct tag value combinations allowed for this metric. + example: 10000 + format: int64 + maximum: 1000000 + minimum: 0 + type: integer + required: + - metric_name + - mode + - limit_exceeded_action + - value_limit + type: object + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode: + description: How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely. + enum: + - tracked + - excluded + example: tracked + type: string + x-enum-varnames: + - TRACKED + - EXCLUDED + ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit: + description: A cardinality override for a specific tag key within a per-metric limit. + properties: + mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode" + tag_key: + description: The tag key this override applies to. + example: "host" + type: string + value_limit: + description: The maximum number of distinct values allowed for this tag. + example: 5000 + format: int64 + maximum: 1000000 + minimum: 0 + type: integer + required: + - tag_key + - mode + - value_limit + type: object + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode: + description: How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. + enum: + - limit_override + - excluded + example: limit_override + type: string + x-enum-varnames: + - LIMIT_OVERRIDE + - EXCLUDED + ObservabilityPipelineTagCardinalityLimitProcessorType: + default: tag_cardinality_limit + description: The processor type. The value should always be `tag_cardinality_limit`. + enum: [tag_cardinality_limit] + example: tag_cardinality_limit + type: string + x-enum-varnames: + - TAG_CARDINALITY_LIMIT ObservabilityPipelineThrottleProcessor: description: |- The `throttle` processor limits the number of events that pass through over a given time window. diff --git a/docs/datadog_api_client.v2.model.rst b/docs/datadog_api_client.v2.model.rst index 0c5968992f..896497a23b 100644 --- a/docs/datadog_api_client.v2.model.rst +++ b/docs/datadog_api_client.v2.model.rst @@ -20913,6 +20913,41 @@ datadog\_api\_client.v2.model.observability\_pipeline\_add\_hostname\_processor\ :members: :show-inheritance: +datadog\_api\_client.v2.model.observability\_pipeline\_add\_metric\_tags\_processor module +------------------------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_add\_metric\_tags\_processor\_type module +------------------------------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor_type + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_aggregate\_processor module +---------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_aggregate_processor + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_aggregate\_processor\_mode module +---------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_aggregate_processor_mode + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_aggregate\_processor\_type module +---------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_aggregate_processor_type + :members: + :show-inheritance: + datadog\_api\_client.v2.model.observability\_pipeline\_amazon\_data\_firehose\_source module -------------------------------------------------------------------------------------------- @@ -22278,6 +22313,27 @@ datadog\_api\_client.v2.model.observability\_pipeline\_rename\_fields\_processor :members: :show-inheritance: +datadog\_api\_client.v2.model.observability\_pipeline\_rename\_metric\_tags\_processor module +--------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_rename\_metric\_tags\_processor\_tag module +-------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_tag + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_rename\_metric\_tags\_processor\_type module +--------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_type + :members: + :show-inheritance: + datadog\_api\_client.v2.model.observability\_pipeline\_rsyslog\_destination module ---------------------------------------------------------------------------------- @@ -22887,6 +22943,55 @@ datadog\_api\_client.v2.model.observability\_pipeline\_syslog\_source\_mode modu :members: :show-inheritance: +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor module +------------------------------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_action module +-------------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_per\_metric\_limit module +-------------------------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_limit + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_per\_metric\_mode module +------------------------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_mode + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_per\_tag\_limit module +----------------------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_limit + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_per\_tag\_mode module +---------------------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_mode + :members: + :show-inheritance: + +datadog\_api\_client.v2.model.observability\_pipeline\_tag\_cardinality\_limit\_processor\_type module +------------------------------------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_type + :members: + :show-inheritance: + datadog\_api\_client.v2.model.observability\_pipeline\_throttle\_processor module --------------------------------------------------------------------------------- diff --git a/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor.py b/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor.py new file mode 100644 index 0000000000..f0b8bd1f93 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor.py @@ -0,0 +1,96 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_field_value import ObservabilityPipelineFieldValue + from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor_type import ( + ObservabilityPipelineAddMetricTagsProcessorType, + ) + + +class ObservabilityPipelineAddMetricTagsProcessor(ModelNormal): + validations = { + "tags": { + "max_items": 15, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_field_value import ObservabilityPipelineFieldValue + from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor_type import ( + ObservabilityPipelineAddMetricTagsProcessorType, + ) + + return { + "display_name": (str,), + "enabled": (bool,), + "id": (str,), + "include": (str,), + "tags": ([ObservabilityPipelineFieldValue],), + "type": (ObservabilityPipelineAddMetricTagsProcessorType,), + } + + attribute_map = { + "display_name": "display_name", + "enabled": "enabled", + "id": "id", + "include": "include", + "tags": "tags", + "type": "type", + } + + def __init__( + self_, + enabled: bool, + id: str, + include: str, + tags: List[ObservabilityPipelineFieldValue], + type: ObservabilityPipelineAddMetricTagsProcessorType, + display_name: Union[str, UnsetType] = unset, + **kwargs, + ): + """ + The ``add_metric_tags`` processor adds static tags to metrics. + + **Supported pipeline types:** metrics + + :param display_name: The display name for a component. + :type display_name: str, optional + + :param enabled: Indicates whether the processor is enabled. + :type enabled: bool + + :param id: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the ``input`` to downstream components). + :type id: str + + :param include: A Datadog search query used to determine which metrics this processor targets. + :type include: str + + :param tags: A list of static tags (key-value pairs) added to each metric processed by this component. + :type tags: [ObservabilityPipelineFieldValue] + + :param type: The processor type. The value should always be ``add_metric_tags``. + :type type: ObservabilityPipelineAddMetricTagsProcessorType + """ + if display_name is not unset: + kwargs["display_name"] = display_name + super().__init__(kwargs) + + self_.enabled = enabled + self_.id = id + self_.include = include + self_.tags = tags + self_.type = type diff --git a/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor_type.py b/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor_type.py new file mode 100644 index 0000000000..5e11ba9367 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_add_metric_tags_processor_type.py @@ -0,0 +1,37 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineAddMetricTagsProcessorType(ModelSimple): + """ + The processor type. The value should always be `add_metric_tags`. + + :param value: If omitted defaults to "add_metric_tags". Must be one of ["add_metric_tags"]. + :type value: str + """ + + allowed_values = { + "add_metric_tags", + } + ADD_METRIC_TAGS: ClassVar["ObservabilityPipelineAddMetricTagsProcessorType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineAddMetricTagsProcessorType.ADD_METRIC_TAGS = ObservabilityPipelineAddMetricTagsProcessorType( + "add_metric_tags" +) diff --git a/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor.py b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor.py new file mode 100644 index 0000000000..d50a241ace --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor.py @@ -0,0 +1,108 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_mode import ( + ObservabilityPipelineAggregateProcessorMode, + ) + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_type import ( + ObservabilityPipelineAggregateProcessorType, + ) + + +class ObservabilityPipelineAggregateProcessor(ModelNormal): + validations = { + "interval_secs": { + "inclusive_maximum": 60, + "inclusive_minimum": 1, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_mode import ( + ObservabilityPipelineAggregateProcessorMode, + ) + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_type import ( + ObservabilityPipelineAggregateProcessorType, + ) + + return { + "display_name": (str,), + "enabled": (bool,), + "id": (str,), + "include": (str,), + "interval_secs": (int,), + "mode": (ObservabilityPipelineAggregateProcessorMode,), + "type": (ObservabilityPipelineAggregateProcessorType,), + } + + attribute_map = { + "display_name": "display_name", + "enabled": "enabled", + "id": "id", + "include": "include", + "interval_secs": "interval_secs", + "mode": "mode", + "type": "type", + } + + def __init__( + self_, + enabled: bool, + id: str, + include: str, + interval_secs: int, + mode: ObservabilityPipelineAggregateProcessorMode, + type: ObservabilityPipelineAggregateProcessorType, + display_name: Union[str, UnsetType] = unset, + **kwargs, + ): + """ + The ``aggregate`` processor combines metrics that share the same name and tags into a single metric over a configurable interval. + + **Supported pipeline types:** metrics + + :param display_name: The display name for a component. + :type display_name: str, optional + + :param enabled: Indicates whether the processor is enabled. + :type enabled: bool + + :param id: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the ``input`` to downstream components). + :type id: str + + :param include: A Datadog search query used to determine which metrics this processor targets. + :type include: str + + :param interval_secs: The interval, in seconds, over which metrics are aggregated. + :type interval_secs: int + + :param mode: The aggregation mode applied to metrics that share the same name and tags within the interval. + :type mode: ObservabilityPipelineAggregateProcessorMode + + :param type: The processor type. The value should always be ``aggregate``. + :type type: ObservabilityPipelineAggregateProcessorType + """ + if display_name is not unset: + kwargs["display_name"] = display_name + super().__init__(kwargs) + + self_.enabled = enabled + self_.id = id + self_.include = include + self_.interval_secs = interval_secs + self_.mode = mode + self_.type = type diff --git a/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_mode.py b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_mode.py new file mode 100644 index 0000000000..4ea2f34b72 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_mode.py @@ -0,0 +1,53 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineAggregateProcessorMode(ModelSimple): + """ + The aggregation mode applied to metrics that share the same name and tags within the interval. + + :param value: Must be one of ["auto", "sum", "latest", "count", "max", "min", "mean"]. + :type value: str + """ + + allowed_values = { + "auto", + "sum", + "latest", + "count", + "max", + "min", + "mean", + } + AUTO: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + SUM: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + LATEST: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + COUNT: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + MAX: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + MIN: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + MEAN: ClassVar["ObservabilityPipelineAggregateProcessorMode"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineAggregateProcessorMode.AUTO = ObservabilityPipelineAggregateProcessorMode("auto") +ObservabilityPipelineAggregateProcessorMode.SUM = ObservabilityPipelineAggregateProcessorMode("sum") +ObservabilityPipelineAggregateProcessorMode.LATEST = ObservabilityPipelineAggregateProcessorMode("latest") +ObservabilityPipelineAggregateProcessorMode.COUNT = ObservabilityPipelineAggregateProcessorMode("count") +ObservabilityPipelineAggregateProcessorMode.MAX = ObservabilityPipelineAggregateProcessorMode("max") +ObservabilityPipelineAggregateProcessorMode.MIN = ObservabilityPipelineAggregateProcessorMode("min") +ObservabilityPipelineAggregateProcessorMode.MEAN = ObservabilityPipelineAggregateProcessorMode("mean") diff --git a/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_type.py b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_type.py new file mode 100644 index 0000000000..98d6544b31 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_aggregate_processor_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineAggregateProcessorType(ModelSimple): + """ + The processor type. The value should always be `aggregate`. + + :param value: If omitted defaults to "aggregate". Must be one of ["aggregate"]. + :type value: str + """ + + allowed_values = { + "aggregate", + } + AGGREGATE: ClassVar["ObservabilityPipelineAggregateProcessorType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineAggregateProcessorType.AGGREGATE = ObservabilityPipelineAggregateProcessorType("aggregate") diff --git a/src/datadog_api_client/v2/model/observability_pipeline_config_processor_group.py b/src/datadog_api_client/v2/model/observability_pipeline_config_processor_group.py index 62bba716b5..4f47b4b242 100644 --- a/src/datadog_api_client/v2/model/observability_pipeline_config_processor_group.py +++ b/src/datadog_api_client/v2/model/observability_pipeline_config_processor_group.py @@ -68,9 +68,21 @@ from datadog_api_client.v2.model.observability_pipeline_throttle_processor import ( ObservabilityPipelineThrottleProcessor, ) + from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor import ( + ObservabilityPipelineAddMetricTagsProcessor, + ) + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor import ( + ObservabilityPipelineAggregateProcessor, + ) from datadog_api_client.v2.model.observability_pipeline_metric_tags_processor import ( ObservabilityPipelineMetricTagsProcessor, ) + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor import ( + ObservabilityPipelineRenameMetricTagsProcessor, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor import ( + ObservabilityPipelineTagCardinalityLimitProcessor, + ) class ObservabilityPipelineConfigProcessorGroup(ModelNormal): @@ -128,7 +140,11 @@ def __init__( ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineSplitArrayProcessor, ObservabilityPipelineThrottleProcessor, + ObservabilityPipelineAddMetricTagsProcessor, + ObservabilityPipelineAggregateProcessor, ObservabilityPipelineMetricTagsProcessor, + ObservabilityPipelineRenameMetricTagsProcessor, + ObservabilityPipelineTagCardinalityLimitProcessor, ] ], display_name: Union[str, UnsetType] = unset, diff --git a/src/datadog_api_client/v2/model/observability_pipeline_config_processor_item.py b/src/datadog_api_client/v2/model/observability_pipeline_config_processor_item.py index 2f546ac29b..50f54e3a3f 100644 --- a/src/datadog_api_client/v2/model/observability_pipeline_config_processor_item.py +++ b/src/datadog_api_client/v2/model/observability_pipeline_config_processor_item.py @@ -149,6 +149,21 @@ def __init__(self, **kwargs): :param window: The time window in seconds over which the threshold applies. :type window: float + + :param tags: A list of static tags (key-value pairs) added to each metric processed by this component. + :type tags: [ObservabilityPipelineFieldValue] + + :param interval_secs: The interval, in seconds, over which metrics are aggregated. + :type interval_secs: int + + :param limit_exceeded_action: The action to take when the cardinality limit is exceeded. + :type limit_exceeded_action: ObservabilityPipelineTagCardinalityLimitProcessorAction + + :param per_metric_limits: A list of per-metric cardinality overrides that take precedence over the default `value_limit`. + :type per_metric_limits: [ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit], optional + + :param value_limit: The default maximum number of distinct tag value combinations allowed per metric. + :type value_limit: int """ super().__init__(kwargs) @@ -224,9 +239,21 @@ def _composed_schemas(_): from datadog_api_client.v2.model.observability_pipeline_throttle_processor import ( ObservabilityPipelineThrottleProcessor, ) + from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor import ( + ObservabilityPipelineAddMetricTagsProcessor, + ) + from datadog_api_client.v2.model.observability_pipeline_aggregate_processor import ( + ObservabilityPipelineAggregateProcessor, + ) from datadog_api_client.v2.model.observability_pipeline_metric_tags_processor import ( ObservabilityPipelineMetricTagsProcessor, ) + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor import ( + ObservabilityPipelineRenameMetricTagsProcessor, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor import ( + ObservabilityPipelineTagCardinalityLimitProcessor, + ) return { "oneOf": [ @@ -251,6 +278,10 @@ def _composed_schemas(_): ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineSplitArrayProcessor, ObservabilityPipelineThrottleProcessor, + ObservabilityPipelineAddMetricTagsProcessor, + ObservabilityPipelineAggregateProcessor, ObservabilityPipelineMetricTagsProcessor, + ObservabilityPipelineRenameMetricTagsProcessor, + ObservabilityPipelineTagCardinalityLimitProcessor, ], } diff --git a/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor.py b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor.py new file mode 100644 index 0000000000..5a90fd680f --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor.py @@ -0,0 +1,100 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_tag import ( + ObservabilityPipelineRenameMetricTagsProcessorTag, + ) + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_type import ( + ObservabilityPipelineRenameMetricTagsProcessorType, + ) + + +class ObservabilityPipelineRenameMetricTagsProcessor(ModelNormal): + validations = { + "tags": { + "max_items": 15, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_tag import ( + ObservabilityPipelineRenameMetricTagsProcessorTag, + ) + from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_type import ( + ObservabilityPipelineRenameMetricTagsProcessorType, + ) + + return { + "display_name": (str,), + "enabled": (bool,), + "id": (str,), + "include": (str,), + "tags": ([ObservabilityPipelineRenameMetricTagsProcessorTag],), + "type": (ObservabilityPipelineRenameMetricTagsProcessorType,), + } + + attribute_map = { + "display_name": "display_name", + "enabled": "enabled", + "id": "id", + "include": "include", + "tags": "tags", + "type": "type", + } + + def __init__( + self_, + enabled: bool, + id: str, + include: str, + tags: List[ObservabilityPipelineRenameMetricTagsProcessorTag], + type: ObservabilityPipelineRenameMetricTagsProcessorType, + display_name: Union[str, UnsetType] = unset, + **kwargs, + ): + """ + The ``rename_metric_tags`` processor changes the keys of tags on metrics. + + **Supported pipeline types:** metrics + + :param display_name: The display name for a component. + :type display_name: str, optional + + :param enabled: Indicates whether the processor is enabled. + :type enabled: bool + + :param id: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the ``input`` to downstream components). + :type id: str + + :param include: A Datadog search query used to determine which metrics this processor targets. + :type include: str + + :param tags: A list of rename rules specifying which tag keys to rename on each metric. + :type tags: [ObservabilityPipelineRenameMetricTagsProcessorTag] + + :param type: The processor type. The value should always be ``rename_metric_tags``. + :type type: ObservabilityPipelineRenameMetricTagsProcessorType + """ + if display_name is not unset: + kwargs["display_name"] = display_name + super().__init__(kwargs) + + self_.enabled = enabled + self_.id = id + self_.include = include + self_.tags = tags + self_.type = type diff --git a/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_tag.py b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_tag.py new file mode 100644 index 0000000000..c9918ff8c0 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_tag.py @@ -0,0 +1,39 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +class ObservabilityPipelineRenameMetricTagsProcessorTag(ModelNormal): + @cached_property + def openapi_types(_): + return { + "rename_to": (str,), + "tag": (str,), + } + + attribute_map = { + "rename_to": "rename_to", + "tag": "tag", + } + + def __init__(self_, rename_to: str, tag: str, **kwargs): + """ + Defines how to rename a tag on metric events. + + :param rename_to: The new tag key to assign in place of the original. + :type rename_to: str + + :param tag: The original tag key on the metric event. + :type tag: str + """ + super().__init__(kwargs) + + self_.rename_to = rename_to + self_.tag = tag diff --git a/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_type.py b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_type.py new file mode 100644 index 0000000000..dd479d2ae6 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_rename_metric_tags_processor_type.py @@ -0,0 +1,37 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineRenameMetricTagsProcessorType(ModelSimple): + """ + The processor type. The value should always be `rename_metric_tags`. + + :param value: If omitted defaults to "rename_metric_tags". Must be one of ["rename_metric_tags"]. + :type value: str + """ + + allowed_values = { + "rename_metric_tags", + } + RENAME_METRIC_TAGS: ClassVar["ObservabilityPipelineRenameMetricTagsProcessorType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineRenameMetricTagsProcessorType.RENAME_METRIC_TAGS = ( + ObservabilityPipelineRenameMetricTagsProcessorType("rename_metric_tags") +) diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor.py new file mode 100644 index 0000000000..a5ae00bab9 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor.py @@ -0,0 +1,127 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action import ( + ObservabilityPipelineTagCardinalityLimitProcessorAction, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_type import ( + ObservabilityPipelineTagCardinalityLimitProcessorType, + ) + + +class ObservabilityPipelineTagCardinalityLimitProcessor(ModelNormal): + validations = { + "per_metric_limits": { + "max_items": 100, + }, + "value_limit": { + "inclusive_maximum": 1000000, + "inclusive_minimum": 0, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action import ( + ObservabilityPipelineTagCardinalityLimitProcessorAction, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_type import ( + ObservabilityPipelineTagCardinalityLimitProcessorType, + ) + + return { + "display_name": (str,), + "enabled": (bool,), + "id": (str,), + "include": (str,), + "limit_exceeded_action": (ObservabilityPipelineTagCardinalityLimitProcessorAction,), + "per_metric_limits": ([ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit],), + "type": (ObservabilityPipelineTagCardinalityLimitProcessorType,), + "value_limit": (int,), + } + + attribute_map = { + "display_name": "display_name", + "enabled": "enabled", + "id": "id", + "include": "include", + "limit_exceeded_action": "limit_exceeded_action", + "per_metric_limits": "per_metric_limits", + "type": "type", + "value_limit": "value_limit", + } + + def __init__( + self_, + enabled: bool, + id: str, + include: str, + limit_exceeded_action: ObservabilityPipelineTagCardinalityLimitProcessorAction, + type: ObservabilityPipelineTagCardinalityLimitProcessorType, + value_limit: int, + display_name: Union[str, UnsetType] = unset, + per_metric_limits: Union[ + List[ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit], UnsetType + ] = unset, + **kwargs, + ): + """ + The ``tag_cardinality_limit`` processor caps the number of distinct tag value combinations on metrics, dropping tags or events once the limit is exceeded. + + **Supported pipeline types:** metrics + + :param display_name: The display name for a component. + :type display_name: str, optional + + :param enabled: Indicates whether the processor is enabled. + :type enabled: bool + + :param id: The unique identifier for this component. Used in other parts of the pipeline to reference this component (for example, as the ``input`` to downstream components). + :type id: str + + :param include: A Datadog search query used to determine which metrics this processor targets. + :type include: str + + :param limit_exceeded_action: The action to take when the cardinality limit is exceeded. + :type limit_exceeded_action: ObservabilityPipelineTagCardinalityLimitProcessorAction + + :param per_metric_limits: A list of per-metric cardinality overrides that take precedence over the default ``value_limit``. + :type per_metric_limits: [ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit], optional + + :param type: The processor type. The value should always be ``tag_cardinality_limit``. + :type type: ObservabilityPipelineTagCardinalityLimitProcessorType + + :param value_limit: The default maximum number of distinct tag value combinations allowed per metric. + :type value_limit: int + """ + if display_name is not unset: + kwargs["display_name"] = display_name + if per_metric_limits is not unset: + kwargs["per_metric_limits"] = per_metric_limits + super().__init__(kwargs) + + self_.enabled = enabled + self_.id = id + self_.include = include + self_.limit_exceeded_action = limit_exceeded_action + self_.type = type + self_.value_limit = value_limit diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_action.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_action.py new file mode 100644 index 0000000000..d395d874b8 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_action.py @@ -0,0 +1,42 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineTagCardinalityLimitProcessorAction(ModelSimple): + """ + The action to take when the cardinality limit is exceeded. + + :param value: Must be one of ["drop_tag", "drop_event"]. + :type value: str + """ + + allowed_values = { + "drop_tag", + "drop_event", + } + DROP_TAG: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorAction"] + DROP_EVENT: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorAction"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineTagCardinalityLimitProcessorAction.DROP_TAG = ( + ObservabilityPipelineTagCardinalityLimitProcessorAction("drop_tag") +) +ObservabilityPipelineTagCardinalityLimitProcessorAction.DROP_EVENT = ( + ObservabilityPipelineTagCardinalityLimitProcessorAction("drop_event") +) diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.py new file mode 100644 index 0000000000..fc0f0e90b1 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.py @@ -0,0 +1,101 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action import ( + ObservabilityPipelineTagCardinalityLimitProcessorAction, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit, + ) + + +class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit(ModelNormal): + validations = { + "per_tag_limits": { + "max_items": 50, + }, + "value_limit": { + "inclusive_maximum": 1000000, + "inclusive_minimum": 0, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action import ( + ObservabilityPipelineTagCardinalityLimitProcessorAction, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode, + ) + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit, + ) + + return { + "limit_exceeded_action": (ObservabilityPipelineTagCardinalityLimitProcessorAction,), + "metric_name": (str,), + "mode": (ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode,), + "per_tag_limits": ([ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit],), + "value_limit": (int,), + } + + attribute_map = { + "limit_exceeded_action": "limit_exceeded_action", + "metric_name": "metric_name", + "mode": "mode", + "per_tag_limits": "per_tag_limits", + "value_limit": "value_limit", + } + + def __init__( + self_, + limit_exceeded_action: ObservabilityPipelineTagCardinalityLimitProcessorAction, + metric_name: str, + mode: ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode, + value_limit: int, + per_tag_limits: Union[List[ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit], UnsetType] = unset, + **kwargs, + ): + """ + A cardinality override applied to a specific metric. + + :param limit_exceeded_action: The action to take when the cardinality limit is exceeded. + :type limit_exceeded_action: ObservabilityPipelineTagCardinalityLimitProcessorAction + + :param metric_name: The name of the metric this override applies to. + :type metric_name: str + + :param mode: How the per-metric override is applied. ``tracked`` enforces a custom limit; ``excluded`` skips the metric entirely. + :type mode: ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode + + :param per_tag_limits: A list of per-tag cardinality overrides that apply within this metric. + :type per_tag_limits: [ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit], optional + + :param value_limit: The maximum number of distinct tag value combinations allowed for this metric. + :type value_limit: int + """ + if per_tag_limits is not unset: + kwargs["per_tag_limits"] = per_tag_limits + super().__init__(kwargs) + + self_.limit_exceeded_action = limit_exceeded_action + self_.metric_name = metric_name + self_.mode = mode + self_.value_limit = value_limit diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.py new file mode 100644 index 0000000000..31534c0c16 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.py @@ -0,0 +1,42 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode(ModelSimple): + """ + How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely. + + :param value: Must be one of ["tracked", "excluded"]. + :type value: str + """ + + allowed_values = { + "tracked", + "excluded", + } + TRACKED: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode"] + EXCLUDED: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode.TRACKED = ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode("tracked") +) +ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode.EXCLUDED = ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode("excluded") +) diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.py new file mode 100644 index 0000000000..d8e10d612e --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.py @@ -0,0 +1,69 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, + ) + + +class ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit(ModelNormal): + validations = { + "value_limit": { + "inclusive_maximum": 1000000, + "inclusive_minimum": 0, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, + ) + + return { + "mode": (ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode,), + "tag_key": (str,), + "value_limit": (int,), + } + + attribute_map = { + "mode": "mode", + "tag_key": "tag_key", + "value_limit": "value_limit", + } + + def __init__( + self_, + mode: ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, + tag_key: str, + value_limit: int, + **kwargs, + ): + """ + A cardinality override for a specific tag key within a per-metric limit. + + :param mode: How the per-tag override is applied. ``limit_override`` enforces a custom limit on the tag; ``excluded`` skips the tag from cardinality tracking. + :type mode: ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode + + :param tag_key: The tag key this override applies to. + :type tag_key: str + + :param value_limit: The maximum number of distinct values allowed for this tag. + :type value_limit: int + """ + super().__init__(kwargs) + + self_.mode = mode + self_.tag_key = tag_key + self_.value_limit = value_limit diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.py new file mode 100644 index 0000000000..c49352f06e --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.py @@ -0,0 +1,42 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode(ModelSimple): + """ + How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. + + :param value: Must be one of ["limit_override", "excluded"]. + :type value: str + """ + + allowed_values = { + "limit_override", + "excluded", + } + LIMIT_OVERRIDE: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode"] + EXCLUDED: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode.LIMIT_OVERRIDE = ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode("limit_override") +) +ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode.EXCLUDED = ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode("excluded") +) diff --git a/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_type.py b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_type.py new file mode 100644 index 0000000000..773ba9e763 --- /dev/null +++ b/src/datadog_api_client/v2/model/observability_pipeline_tag_cardinality_limit_processor_type.py @@ -0,0 +1,37 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class ObservabilityPipelineTagCardinalityLimitProcessorType(ModelSimple): + """ + The processor type. The value should always be `tag_cardinality_limit`. + + :param value: If omitted defaults to "tag_cardinality_limit". Must be one of ["tag_cardinality_limit"]. + :type value: str + """ + + allowed_values = { + "tag_cardinality_limit", + } + TAG_CARDINALITY_LIMIT: ClassVar["ObservabilityPipelineTagCardinalityLimitProcessorType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +ObservabilityPipelineTagCardinalityLimitProcessorType.TAG_CARDINALITY_LIMIT = ( + ObservabilityPipelineTagCardinalityLimitProcessorType("tag_cardinality_limit") +) diff --git a/src/datadog_api_client/v2/models/__init__.py b/src/datadog_api_client/v2/models/__init__.py index a3fe5f6f9d..aa578b9a8b 100644 --- a/src/datadog_api_client/v2/models/__init__.py +++ b/src/datadog_api_client/v2/models/__init__.py @@ -3991,6 +3991,21 @@ from datadog_api_client.v2.model.observability_pipeline_add_hostname_processor_type import ( ObservabilityPipelineAddHostnameProcessorType, ) +from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor import ( + ObservabilityPipelineAddMetricTagsProcessor, +) +from datadog_api_client.v2.model.observability_pipeline_add_metric_tags_processor_type import ( + ObservabilityPipelineAddMetricTagsProcessorType, +) +from datadog_api_client.v2.model.observability_pipeline_aggregate_processor import ( + ObservabilityPipelineAggregateProcessor, +) +from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_mode import ( + ObservabilityPipelineAggregateProcessorMode, +) +from datadog_api_client.v2.model.observability_pipeline_aggregate_processor_type import ( + ObservabilityPipelineAggregateProcessorType, +) from datadog_api_client.v2.model.observability_pipeline_amazon_data_firehose_source import ( ObservabilityPipelineAmazonDataFirehoseSource, ) @@ -4525,6 +4540,15 @@ from datadog_api_client.v2.model.observability_pipeline_rename_fields_processor_type import ( ObservabilityPipelineRenameFieldsProcessorType, ) +from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor import ( + ObservabilityPipelineRenameMetricTagsProcessor, +) +from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_tag import ( + ObservabilityPipelineRenameMetricTagsProcessorTag, +) +from datadog_api_client.v2.model.observability_pipeline_rename_metric_tags_processor_type import ( + ObservabilityPipelineRenameMetricTagsProcessorType, +) from datadog_api_client.v2.model.observability_pipeline_rsyslog_destination import ( ObservabilityPipelineRsyslogDestination, ) @@ -4760,6 +4784,27 @@ ObservabilityPipelineSyslogNgSourceType, ) from datadog_api_client.v2.model.observability_pipeline_syslog_source_mode import ObservabilityPipelineSyslogSourceMode +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor import ( + ObservabilityPipelineTagCardinalityLimitProcessor, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_action import ( + ObservabilityPipelineTagCardinalityLimitProcessorAction, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_metric_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_limit import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_per_tag_mode import ( + ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, +) +from datadog_api_client.v2.model.observability_pipeline_tag_cardinality_limit_processor_type import ( + ObservabilityPipelineTagCardinalityLimitProcessorType, +) from datadog_api_client.v2.model.observability_pipeline_throttle_processor import ObservabilityPipelineThrottleProcessor from datadog_api_client.v2.model.observability_pipeline_throttle_processor_type import ( ObservabilityPipelineThrottleProcessorType, @@ -10700,6 +10745,11 @@ "ObservabilityPipelineAddFieldsProcessorType", "ObservabilityPipelineAddHostnameProcessor", "ObservabilityPipelineAddHostnameProcessorType", + "ObservabilityPipelineAddMetricTagsProcessor", + "ObservabilityPipelineAddMetricTagsProcessorType", + "ObservabilityPipelineAggregateProcessor", + "ObservabilityPipelineAggregateProcessorMode", + "ObservabilityPipelineAggregateProcessorType", "ObservabilityPipelineAmazonDataFirehoseSource", "ObservabilityPipelineAmazonDataFirehoseSourceType", "ObservabilityPipelineAmazonOpenSearchDestination", @@ -10896,6 +10946,9 @@ "ObservabilityPipelineRenameFieldsProcessor", "ObservabilityPipelineRenameFieldsProcessorField", "ObservabilityPipelineRenameFieldsProcessorType", + "ObservabilityPipelineRenameMetricTagsProcessor", + "ObservabilityPipelineRenameMetricTagsProcessorTag", + "ObservabilityPipelineRenameMetricTagsProcessorType", "ObservabilityPipelineRsyslogDestination", "ObservabilityPipelineRsyslogDestinationType", "ObservabilityPipelineRsyslogSource", @@ -10983,6 +11036,13 @@ "ObservabilityPipelineSyslogNgSource", "ObservabilityPipelineSyslogNgSourceType", "ObservabilityPipelineSyslogSourceMode", + "ObservabilityPipelineTagCardinalityLimitProcessor", + "ObservabilityPipelineTagCardinalityLimitProcessorAction", + "ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit", + "ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode", + "ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit", + "ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode", + "ObservabilityPipelineTagCardinalityLimitProcessorType", "ObservabilityPipelineThrottleProcessor", "ObservabilityPipelineThrottleProcessorType", "ObservabilityPipelineTls",