From f5564f6810f05310eda2fad03ec352051fac0200 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Thu, 9 Jul 2026 16:19:24 +0000 Subject: [PATCH] Regenerate client from commit 51c18d8 of spec repo --- .generator/schemas/v2/openapi.yaml | 61 +++++---- lib/datadog_api_client/inflector.rb | 5 +- ...ipeline_tag_cardinality_limit_processor.rb | 23 +++- ...dinality_limit_processor_override_type.rb} | 4 +- ...nality_limit_processor_per_metric_limit.rb | 32 ++--- ...rdinality_limit_processor_per_tag_limit.rb | 30 ++--- ...rdinality_limit_processor_tracking_mode.rb | 123 ++++++++++++++++++ ...ity_limit_processor_tracking_mode_mode.rb} | 8 +- 8 files changed, 221 insertions(+), 65 deletions(-) rename lib/datadog_api_client/v2/models/{observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rb => observability_pipeline_tag_cardinality_limit_processor_override_type.rb} (75%) create mode 100644 lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rb rename lib/datadog_api_client/v2/models/{observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rb => observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rb} (69%) diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c2aa6fb6864f..1d90d8e90909 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -70300,6 +70300,8 @@ components: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit" maxItems: 100 type: array + tracking_mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode" type: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorType" value_limit: @@ -70314,6 +70316,7 @@ components: - type - include - limit_exceeded_action + - tracking_mode - value_limit - enabled type: object @@ -70328,6 +70331,16 @@ components: x-enum-varnames: - DROP_TAG - DROP_EVENT + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType: + description: How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking. + enum: + - limit_override + - excluded + example: limit_override + type: string + x-enum-varnames: + - LIMIT_OVERRIDE + - EXCLUDED ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit: description: A cardinality override applied to a specific metric. properties: @@ -70337,16 +70350,16 @@ components: description: The name of the metric this override applies to. example: "system.cpu.user" type: string - mode: - $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode" + override_type: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType" per_tag_limits: - description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `mode` is `excluded`. + description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `override_type` is `excluded`. items: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit" maxItems: 50 type: array value_limit: - description: The maximum number of distinct tag value combinations allowed for this metric. Required when `mode` is `tracked`. Must be omitted when `mode` is `excluded`. + description: The maximum number of distinct tag value combinations allowed for this metric. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. example: 10000 format: int64 maximum: 1000000 @@ -70354,29 +70367,19 @@ components: type: integer required: - metric_name - - mode + - override_type 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" + override_type: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType" 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. Required when `mode` is `limit_override`. Must be omitted when `mode` is `excluded`. + description: The maximum number of distinct values allowed for this tag. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. example: 5000 format: int64 maximum: 1000000 @@ -70384,18 +70387,26 @@ components: type: integer required: - tag_key + - override_type + type: object + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode: + description: Controls whether the processor uses exact or probabilistic tag tracking. + properties: + mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode" + required: - mode 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. + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode: + description: The cardinality tracking algorithm to use. enum: - - limit_override - - excluded - example: limit_override + - exact_fingerprint + - probabilistic + example: exact_fingerprint type: string x-enum-varnames: - - LIMIT_OVERRIDE - - EXCLUDED + - EXACT_FINGERPRINT + - PROBABILISTIC ObservabilityPipelineTagCardinalityLimitProcessorType: default: tag_cardinality_limit description: The processor type. The value must be `tag_cardinality_limit`. diff --git a/lib/datadog_api_client/inflector.rb b/lib/datadog_api_client/inflector.rb index bb489f2e6b16..cbfb25acdd24 100644 --- a/lib/datadog_api_client/inflector.rb +++ b/lib/datadog_api_client/inflector.rb @@ -5291,10 +5291,11 @@ def overrides "v2.observability_pipeline_syslog_source_mode" => "ObservabilityPipelineSyslogSourceMode", "v2.observability_pipeline_tag_cardinality_limit_processor" => "ObservabilityPipelineTagCardinalityLimitProcessor", "v2.observability_pipeline_tag_cardinality_limit_processor_action" => "ObservabilityPipelineTagCardinalityLimitProcessorAction", + "v2.observability_pipeline_tag_cardinality_limit_processor_override_type" => "ObservabilityPipelineTagCardinalityLimitProcessorOverrideType", "v2.observability_pipeline_tag_cardinality_limit_processor_per_metric_limit" => "ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit", - "v2.observability_pipeline_tag_cardinality_limit_processor_per_metric_mode" => "ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode", "v2.observability_pipeline_tag_cardinality_limit_processor_per_tag_limit" => "ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit", - "v2.observability_pipeline_tag_cardinality_limit_processor_per_tag_mode" => "ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode", + "v2.observability_pipeline_tag_cardinality_limit_processor_tracking_mode" => "ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode", + "v2.observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode" => "ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode", "v2.observability_pipeline_tag_cardinality_limit_processor_type" => "ObservabilityPipelineTagCardinalityLimitProcessorType", "v2.observability_pipeline_throttle_processor" => "ObservabilityPipelineThrottleProcessor", "v2.observability_pipeline_throttle_processor_type" => "ObservabilityPipelineThrottleProcessorType", diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor.rb index 1b38d76515bb..859f84e4b397 100644 --- a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor.rb +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor.rb @@ -41,6 +41,9 @@ class ObservabilityPipelineTagCardinalityLimitProcessor # A list of per-metric cardinality overrides that take precedence over the default `value_limit`. attr_reader :per_metric_limits + # Controls whether the processor uses exact or probabilistic tag tracking. + attr_reader :tracking_mode + # The processor type. The value must be `tag_cardinality_limit`. attr_reader :type @@ -59,6 +62,7 @@ def self.attribute_map :'include' => :'include', :'limit_exceeded_action' => :'limit_exceeded_action', :'per_metric_limits' => :'per_metric_limits', + :'tracking_mode' => :'tracking_mode', :'type' => :'type', :'value_limit' => :'value_limit' } @@ -74,6 +78,7 @@ def self.openapi_types :'include' => :'String', :'limit_exceeded_action' => :'ObservabilityPipelineTagCardinalityLimitProcessorAction', :'per_metric_limits' => :'Array', + :'tracking_mode' => :'ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode', :'type' => :'ObservabilityPipelineTagCardinalityLimitProcessorType', :'value_limit' => :'Integer' } @@ -123,6 +128,10 @@ def initialize(attributes = {}) end end + if attributes.key?(:'tracking_mode') + self.tracking_mode = attributes[:'tracking_mode'] + end + if attributes.key?(:'type') self.type = attributes[:'type'] end @@ -141,6 +150,7 @@ def valid? return false if @include.nil? return false if @limit_exceeded_action.nil? return false if !@per_metric_limits.nil? && @per_metric_limits.length > 100 + return false if @tracking_mode.nil? return false if @type.nil? return false if @value_limit.nil? return false if @value_limit > 1000000 @@ -198,6 +208,16 @@ def per_metric_limits=(per_metric_limits) @per_metric_limits = per_metric_limits end + # Custom attribute writer method with validation + # @param tracking_mode [Object] Object to be assigned + # @!visibility private + def tracking_mode=(tracking_mode) + if tracking_mode.nil? + fail ArgumentError, 'invalid value for "tracking_mode", tracking_mode cannot be nil.' + end + @tracking_mode = tracking_mode + end + # Custom attribute writer method with validation # @param type [Object] Object to be assigned # @!visibility private @@ -256,6 +276,7 @@ def ==(o) include == o.include && limit_exceeded_action == o.limit_exceeded_action && per_metric_limits == o.per_metric_limits && + tracking_mode == o.tracking_mode && type == o.type && value_limit == o.value_limit && additional_properties == o.additional_properties @@ -265,7 +286,7 @@ def ==(o) # @return [Integer] Hash code # @!visibility private def hash - [display_name, enabled, id, include, limit_exceeded_action, per_metric_limits, type, value_limit, additional_properties].hash + [display_name, enabled, id, include, limit_exceeded_action, per_metric_limits, tracking_mode, type, value_limit, additional_properties].hash end end end diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_override_type.rb similarity index 75% rename from lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rb rename to lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_override_type.rb index 4e2dd13f7af9..55367089f583 100644 --- a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rb +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_override_type.rb @@ -17,8 +17,8 @@ require 'time' module DatadogAPIClient::V2 - # How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. - class ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode + # How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking. + class ObservabilityPipelineTagCardinalityLimitProcessorOverrideType include BaseEnumModel LIMIT_OVERRIDE = "limit_override".freeze diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rb index d6147df8b675..dafd776060ca 100644 --- a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rb +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rb @@ -27,13 +27,13 @@ class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit # The name of the metric this override applies to. attr_reader :metric_name - # How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely. - attr_reader :mode + # How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking. + attr_reader :override_type - # A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `mode` is `excluded`. + # A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `override_type` is `excluded`. attr_reader :per_tag_limits - # The maximum number of distinct tag value combinations allowed for this metric. Required when `mode` is `tracked`. Must be omitted when `mode` is `excluded`. + # The maximum number of distinct tag value combinations allowed for this metric. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. attr_reader :value_limit attr_accessor :additional_properties @@ -44,7 +44,7 @@ def self.attribute_map { :'limit_exceeded_action' => :'limit_exceeded_action', :'metric_name' => :'metric_name', - :'mode' => :'mode', + :'override_type' => :'override_type', :'per_tag_limits' => :'per_tag_limits', :'value_limit' => :'value_limit' } @@ -56,7 +56,7 @@ def self.openapi_types { :'limit_exceeded_action' => :'ObservabilityPipelineTagCardinalityLimitProcessorAction', :'metric_name' => :'String', - :'mode' => :'ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode', + :'override_type' => :'ObservabilityPipelineTagCardinalityLimitProcessorOverrideType', :'per_tag_limits' => :'Array', :'value_limit' => :'Integer' } @@ -88,8 +88,8 @@ def initialize(attributes = {}) self.metric_name = attributes[:'metric_name'] end - if attributes.key?(:'mode') - self.mode = attributes[:'mode'] + if attributes.key?(:'override_type') + self.override_type = attributes[:'override_type'] end if attributes.key?(:'per_tag_limits') @@ -108,7 +108,7 @@ def initialize(attributes = {}) # @!visibility private def valid? return false if @metric_name.nil? - return false if @mode.nil? + return false if @override_type.nil? return false if !@per_tag_limits.nil? && @per_tag_limits.length > 50 return false if !@value_limit.nil? && @value_limit > 1000000 return false if !@value_limit.nil? && @value_limit < 0 @@ -126,13 +126,13 @@ def metric_name=(metric_name) end # Custom attribute writer method with validation - # @param mode [Object] Object to be assigned + # @param override_type [Object] Object to be assigned # @!visibility private - def mode=(mode) - if mode.nil? - fail ArgumentError, 'invalid value for "mode", mode cannot be nil.' + def override_type=(override_type) + if override_type.nil? + fail ArgumentError, 'invalid value for "override_type", override_type cannot be nil.' end - @mode = mode + @override_type = override_type end # Custom attribute writer method with validation @@ -186,7 +186,7 @@ def ==(o) self.class == o.class && limit_exceeded_action == o.limit_exceeded_action && metric_name == o.metric_name && - mode == o.mode && + override_type == o.override_type && per_tag_limits == o.per_tag_limits && value_limit == o.value_limit && additional_properties == o.additional_properties @@ -196,7 +196,7 @@ def ==(o) # @return [Integer] Hash code # @!visibility private def hash - [limit_exceeded_action, metric_name, mode, per_tag_limits, value_limit, additional_properties].hash + [limit_exceeded_action, metric_name, override_type, per_tag_limits, value_limit, additional_properties].hash end end end diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rb index 32ac13afa297..1ebcd5a8355d 100644 --- a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rb +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rb @@ -21,13 +21,13 @@ module DatadogAPIClient::V2 class ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit include BaseGenericModel - # How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. - attr_reader :mode + # How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking. + attr_reader :override_type # The tag key this override applies to. attr_reader :tag_key - # The maximum number of distinct values allowed for this tag. Required when `mode` is `limit_override`. Must be omitted when `mode` is `excluded`. + # The maximum number of distinct values allowed for this tag. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. attr_reader :value_limit attr_accessor :additional_properties @@ -36,7 +36,7 @@ class ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit # @!visibility private def self.attribute_map { - :'mode' => :'mode', + :'override_type' => :'override_type', :'tag_key' => :'tag_key', :'value_limit' => :'value_limit' } @@ -46,7 +46,7 @@ def self.attribute_map # @!visibility private def self.openapi_types { - :'mode' => :'ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode', + :'override_type' => :'ObservabilityPipelineTagCardinalityLimitProcessorOverrideType', :'tag_key' => :'String', :'value_limit' => :'Integer' } @@ -70,8 +70,8 @@ def initialize(attributes = {}) end } - if attributes.key?(:'mode') - self.mode = attributes[:'mode'] + if attributes.key?(:'override_type') + self.override_type = attributes[:'override_type'] end if attributes.key?(:'tag_key') @@ -87,7 +87,7 @@ def initialize(attributes = {}) # @return true if the model is valid # @!visibility private def valid? - return false if @mode.nil? + return false if @override_type.nil? return false if @tag_key.nil? return false if !@value_limit.nil? && @value_limit > 1000000 return false if !@value_limit.nil? && @value_limit < 0 @@ -95,13 +95,13 @@ def valid? end # Custom attribute writer method with validation - # @param mode [Object] Object to be assigned + # @param override_type [Object] Object to be assigned # @!visibility private - def mode=(mode) - if mode.nil? - fail ArgumentError, 'invalid value for "mode", mode cannot be nil.' + def override_type=(override_type) + if override_type.nil? + fail ArgumentError, 'invalid value for "override_type", override_type cannot be nil.' end - @mode = mode + @override_type = override_type end # Custom attribute writer method with validation @@ -153,7 +153,7 @@ def to_hash def ==(o) return true if self.equal?(o) self.class == o.class && - mode == o.mode && + override_type == o.override_type && tag_key == o.tag_key && value_limit == o.value_limit && additional_properties == o.additional_properties @@ -163,7 +163,7 @@ def ==(o) # @return [Integer] Hash code # @!visibility private def hash - [mode, tag_key, value_limit, additional_properties].hash + [override_type, tag_key, value_limit, additional_properties].hash end end end diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rb new file mode 100644 index 000000000000..581c57222e44 --- /dev/null +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rb @@ -0,0 +1,123 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Controls whether the processor uses exact or probabilistic tag tracking. + class ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode + include BaseGenericModel + + # The cardinality tracking algorithm to use. + attr_reader :mode + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'mode' => :'mode' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'mode' => :'ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'mode') + self.mode = attributes[:'mode'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @mode.nil? + true + end + + # Custom attribute writer method with validation + # @param mode [Object] Object to be assigned + # @!visibility private + def mode=(mode) + if mode.nil? + fail ArgumentError, 'invalid value for "mode", mode cannot be nil.' + end + @mode = mode + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + mode == o.mode && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [mode, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rb b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rb similarity index 69% rename from lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rb rename to lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rb index 0a73d35dbc7e..2fb713adf9e6 100644 --- a/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rb +++ b/lib/datadog_api_client/v2/models/observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rb @@ -17,11 +17,11 @@ require 'time' module DatadogAPIClient::V2 - # How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely. - class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode + # The cardinality tracking algorithm to use. + class ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode include BaseEnumModel - TRACKED = "tracked".freeze - EXCLUDED = "excluded".freeze + EXACT_FINGERPRINT = "exact_fingerprint".freeze + PROBABILISTIC = "probabilistic".freeze end end