diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index a76195ae98e..d8e17ba56dc 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -84707,6 +84707,7 @@ components: - $ref: "#/components/schemas/ObservabilityPipelineRenameFieldsProcessor" - $ref: "#/components/schemas/ObservabilityPipelineSampleProcessor" - $ref: "#/components/schemas/ObservabilityPipelineSensitiveDataScannerProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessor" - $ref: "#/components/schemas/ObservabilityPipelineSplitArrayProcessor" - $ref: "#/components/schemas/ObservabilityPipelineThrottleProcessor" - $ref: "#/components/schemas/ObservabilityPipelineAddMetricTagsProcessor" @@ -89159,6 +89160,169 @@ components: - type - attributes type: object + ObservabilityPipelineSpikeProtectionProcessor: + description: |- + The `spike_protection` processor learns the normal ingestion volume for the logs that match a specified filter and takes action when the volume spikes unexpectedly. + + **Supported pipeline types:** logs + properties: + action_when_missing_partitions: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions" + 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: "spike-protection-processor" + type: string + include: + description: A Datadog search query used to determine which logs this processor targets. + example: "service:my-service" + type: string + minimal_threshold: + description: The minimum volume, in bytes, that must be observed within 24 hours before spike protection can activate. Defaults to 100 GiB. + example: 107374182400 + format: int64 + type: integer + minimal_threshold_overrides: + description: A list of per-partition overrides for the minimal threshold, identified by matching field values. Requires `partition_fields` to be set. + items: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorThresholdOverride" + type: array + name: + description: Name of the spike protection rule. + example: MySpikeProtection + type: string + partition_fields: + description: A list of fields used to segment log traffic. Volume is learned and evaluated independently for each unique combination of these field values. A maximum of five fields is supported. + items: + description: The name of a log field used to partition spike detection. + maxLength: 128 + type: string + maxItems: 5 + type: array + uniqueItems: true + spike_action: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorSpikeAction" + spike_threshold: + description: The number of standard deviations above the learned mean volume that must be exceeded before a spike is detected. Defaults to `5`. + example: 5 + format: double + type: number + type: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorType" + required: + - id + - type + - include + - name + - spike_action + - enabled + type: object + x-pipeline-types: [logs] + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions: + default: ignore + description: |- + How to handle logs that are missing one of the `partition_fields`. Options: + - `ignore`: Forward the event without applying spike protection. + - `default_bucket`: Assign the event to a default partition. + enum: + - ignore + - default_bucket + example: ignore + type: string + x-enum-varnames: + - IGNORE + - DEFAULT_BUCKET + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold: + description: The minimal threshold to apply to the matching partition. + oneOf: + - $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes" + - $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep" + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep: + description: Never activates spike protection for the matching partition, regardless of volume. + properties: + type: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType" + required: + - type + type: object + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType: + default: always_keep + description: The minimal threshold type. The value should always be `always_keep`. + enum: + - always_keep + example: always_keep + type: string + x-enum-varnames: + - ALWAYS_KEEP + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes: + description: Sets a specific byte threshold for the matching partition. + properties: + bytes: + description: The minimal threshold, in bytes, for the matching partition. + example: 107374182400 + format: int64 + type: integer + type: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType" + required: + - type + - bytes + type: object + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType: + default: threshold + description: The minimal threshold type. The value should always be `threshold`. + enum: + - threshold + example: threshold + type: string + x-enum-varnames: + - THRESHOLD + ObservabilityPipelineSpikeProtectionProcessorSpikeAction: + description: |- + The action to take with matching logs while spike protection is active. Options: + - `drop`: Drop the event. + - `no_action`: Let the event pass through. + - `overflow_routing`: Route to an overflow destination. + + When `overflow_routing` is used, there must be a destination whose `inputs` reference this processor with the `.overflow_events` suffix to route the overflowing events. + enum: + - drop + - no_action + - overflow_routing + example: drop + type: string + x-enum-varnames: + - DROP + - NO_ACTION + - OVERFLOW_ROUTING + ObservabilityPipelineSpikeProtectionProcessorThresholdOverride: + description: Defines a minimal threshold that applies to a specific partition instead of the processor-wide `minimal_threshold`. + properties: + fields: + description: The set of field matchers that identifies the partition this override applies to. Every field name listed must also appear in `partition_fields`. + items: + $ref: "#/components/schemas/ObservabilityPipelineFieldValue" + type: array + minimal_threshold: + $ref: "#/components/schemas/ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold" + required: + - fields + - minimal_threshold + type: object + ObservabilityPipelineSpikeProtectionProcessorType: + default: spike_protection + description: The processor type. The value should always be `spike_protection`. + enum: + - spike_protection + example: spike_protection + type: string + x-enum-varnames: + - SPIKE_PROTECTION ObservabilityPipelineSplitArrayProcessor: description: |- The `split_array` processor splits array fields into separate events based on configured rules. diff --git a/examples/v2/observability-pipelines/ValidatePipeline_3654691150.java b/examples/v2/observability-pipelines/ValidatePipeline_3654691150.java new file mode 100644 index 00000000000..88763240189 --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_3654691150.java @@ -0,0 +1,145 @@ +// Validate an observability pipeline with spike protection processor threshold overrides returns +// "OK" response + +import com.datadog.api.client.ApiClient; +import com.datadog.api.client.ApiException; +import com.datadog.api.client.v2.api.ObservabilityPipelinesApi; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfig; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigDestinationItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigProcessorGroup; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigProcessorItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigSourceItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineDataAttributes; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogAgentSource; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogAgentSourceType; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogLogsDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogLogsDestinationType; +import com.datadog.api.client.v2.model.ObservabilityPipelineFieldValue; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpec; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpecData; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessor; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorSpikeAction; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorThresholdOverride; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorType; +import com.datadog.api.client.v2.model.ValidationResponse; +import java.util.Arrays; +import java.util.Collections; + +public class Example { + public static void main(String[] args) { + ApiClient defaultClient = ApiClient.getDefaultApiClient(); + defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN")); + ObservabilityPipelinesApi apiInstance = new ObservabilityPipelinesApi(defaultClient); + + ObservabilityPipelineSpec body = + new ObservabilityPipelineSpec() + .data( + new ObservabilityPipelineSpecData() + .attributes( + new ObservabilityPipelineDataAttributes() + .config( + new ObservabilityPipelineConfig() + .destinations( + Collections.singletonList( + new ObservabilityPipelineConfigDestinationItem( + new ObservabilityPipelineDatadogLogsDestination() + .id("datadog-logs-destination") + .inputs( + Collections.singletonList( + "my-processor-group")) + .type( + ObservabilityPipelineDatadogLogsDestinationType + .DATADOG_LOGS)))) + .processorGroups( + Collections.singletonList( + new ObservabilityPipelineConfigProcessorGroup() + .enabled(true) + .id("my-processor-group") + .include("service:my-service") + .inputs( + Collections.singletonList( + "datadog-agent-source")) + .processors( + Collections.singletonList( + new ObservabilityPipelineConfigProcessorItem( + new ObservabilityPipelineSpikeProtectionProcessor() + .enabled(true) + .id("spike-protection-processor") + .include("*") + .type( + ObservabilityPipelineSpikeProtectionProcessorType + .SPIKE_PROTECTION) + .name( + "MyPartitionedSpikeProtection") + .spikeAction( + ObservabilityPipelineSpikeProtectionProcessorSpikeAction + .NO_ACTION) + .partitionFields( + Collections.singletonList( + "service")) + .actionWhenMissingPartitions( + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + .DEFAULT_BUCKET) + .minimalThresholdOverrides( + Arrays.asList( + new ObservabilityPipelineSpikeProtectionProcessorThresholdOverride() + .fields( + Collections + .singletonList( + new ObservabilityPipelineFieldValue() + .name( + "service") + .value( + "checkout"))) + .minimalThreshold( + new ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold( + new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes() + .type( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType + .THRESHOLD) + .bytes( + 53687091200L))), + new ObservabilityPipelineSpikeProtectionProcessorThresholdOverride() + .fields( + Collections + .singletonList( + new ObservabilityPipelineFieldValue() + .name( + "service") + .value( + "payments"))) + .minimalThreshold( + new ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold( + new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep() + .type( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType + .ALWAYS_KEEP)))))))))) + .sources( + Collections.singletonList( + new ObservabilityPipelineConfigSourceItem( + new ObservabilityPipelineDatadogAgentSource() + .id("datadog-agent-source") + .type( + ObservabilityPipelineDatadogAgentSourceType + .DATADOG_AGENT))))) + .name("Pipeline with Spike Protection Threshold Overrides")) + .type("pipelines")); + + try { + ValidationResponse result = apiInstance.validatePipeline(body); + System.out.println(result); + } catch (ApiException e) { + System.err.println("Exception when calling ObservabilityPipelinesApi#validatePipeline"); + System.err.println("Status code: " + e.getCode()); + System.err.println("Reason: " + e.getResponseBody()); + System.err.println("Response headers: " + e.getResponseHeaders()); + e.printStackTrace(); + } + } +} diff --git a/examples/v2/observability-pipelines/ValidatePipeline_3666485614.java b/examples/v2/observability-pipelines/ValidatePipeline_3666485614.java new file mode 100644 index 00000000000..d5ee5fefc5c --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_3666485614.java @@ -0,0 +1,97 @@ +// Validate an observability pipeline with spike protection processor returns "OK" response + +import com.datadog.api.client.ApiClient; +import com.datadog.api.client.ApiException; +import com.datadog.api.client.v2.api.ObservabilityPipelinesApi; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfig; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigDestinationItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigProcessorGroup; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigProcessorItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineConfigSourceItem; +import com.datadog.api.client.v2.model.ObservabilityPipelineDataAttributes; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogAgentSource; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogAgentSourceType; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogLogsDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogLogsDestinationType; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpec; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpecData; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessor; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorSpikeAction; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpikeProtectionProcessorType; +import com.datadog.api.client.v2.model.ValidationResponse; +import java.util.Collections; + +public class Example { + public static void main(String[] args) { + ApiClient defaultClient = ApiClient.getDefaultApiClient(); + defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN")); + ObservabilityPipelinesApi apiInstance = new ObservabilityPipelinesApi(defaultClient); + + ObservabilityPipelineSpec body = + new ObservabilityPipelineSpec() + .data( + new ObservabilityPipelineSpecData() + .attributes( + new ObservabilityPipelineDataAttributes() + .config( + new ObservabilityPipelineConfig() + .destinations( + Collections.singletonList( + new ObservabilityPipelineConfigDestinationItem( + new ObservabilityPipelineDatadogLogsDestination() + .id("datadog-logs-destination") + .inputs( + Collections.singletonList( + "my-processor-group")) + .type( + ObservabilityPipelineDatadogLogsDestinationType + .DATADOG_LOGS)))) + .processorGroups( + Collections.singletonList( + new ObservabilityPipelineConfigProcessorGroup() + .enabled(true) + .id("my-processor-group") + .include("service:my-service") + .inputs( + Collections.singletonList( + "datadog-agent-source")) + .processors( + Collections.singletonList( + new ObservabilityPipelineConfigProcessorItem( + new ObservabilityPipelineSpikeProtectionProcessor() + .enabled(true) + .id("spike-protection-processor") + .include("*") + .type( + ObservabilityPipelineSpikeProtectionProcessorType + .SPIKE_PROTECTION) + .name("MySpikeProtection") + .spikeAction( + ObservabilityPipelineSpikeProtectionProcessorSpikeAction + .DROP) + .spikeThreshold(5.0) + .minimalThreshold( + 107374182400L)))))) + .sources( + Collections.singletonList( + new ObservabilityPipelineConfigSourceItem( + new ObservabilityPipelineDatadogAgentSource() + .id("datadog-agent-source") + .type( + ObservabilityPipelineDatadogAgentSourceType + .DATADOG_AGENT))))) + .name("Pipeline with Spike Protection")) + .type("pipelines")); + + try { + ValidationResponse result = apiInstance.validatePipeline(body); + System.out.println(result); + } catch (ApiException e) { + System.err.println("Exception when calling ObservabilityPipelinesApi#validatePipeline"); + System.err.println("Status code: " + e.getCode()); + System.err.println("Reason: " + e.getResponseBody()); + System.err.println("Response headers: " + e.getResponseHeaders()); + e.printStackTrace(); + } + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java index af7d9e07183..3b6accc83b4 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java @@ -1106,6 +1106,58 @@ public ObservabilityPipelineConfigProcessorItem deserialize( e); } + // deserialize ObservabilityPipelineSpikeProtectionProcessor + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineSpikeProtectionProcessor.class.equals(Integer.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Long.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Float.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Double.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Boolean.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessor.class.equals(Integer.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessor.class.equals(Float.class) + || ObservabilityPipelineSpikeProtectionProcessor.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessor.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessor.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(ObservabilityPipelineSpikeProtectionProcessor.class); + // TODO: there is no validation against JSON schema constraints + // (min, max, enum, pattern...), this does not perform a strict JSON + // validation, which means the 'match' count may be higher than it should be. + if (!((ObservabilityPipelineSpikeProtectionProcessor) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'ObservabilityPipelineSpikeProtectionProcessor'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'ObservabilityPipelineSpikeProtectionProcessor'", + e); + } + // deserialize ObservabilityPipelineSplitArrayProcessor try { boolean attemptParsing = true; @@ -1658,6 +1710,11 @@ public ObservabilityPipelineConfigProcessorItem( setActualInstance(o); } + public ObservabilityPipelineConfigProcessorItem(ObservabilityPipelineSpikeProtectionProcessor o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + public ObservabilityPipelineConfigProcessorItem(ObservabilityPipelineSplitArrayProcessor o) { super("oneOf", Boolean.FALSE); setActualInstance(o); @@ -1762,6 +1819,9 @@ public ObservabilityPipelineConfigProcessorItem( schemas.put( "ObservabilityPipelineSensitiveDataScannerProcessor", new GenericType() {}); + schemas.put( + "ObservabilityPipelineSpikeProtectionProcessor", + new GenericType() {}); schemas.put( "ObservabilityPipelineSplitArrayProcessor", new GenericType() {}); @@ -1807,7 +1867,8 @@ public Map getSchemas() { * ObservabilityPipelineParseXMLProcessor, ObservabilityPipelineQuotaProcessor, * ObservabilityPipelineReduceProcessor, ObservabilityPipelineRemoveFieldsProcessor, * ObservabilityPipelineRenameFieldsProcessor, ObservabilityPipelineSampleProcessor, - * ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineSplitArrayProcessor, + * ObservabilityPipelineSensitiveDataScannerProcessor, + * ObservabilityPipelineSpikeProtectionProcessor, ObservabilityPipelineSplitArrayProcessor, * ObservabilityPipelineThrottleProcessor, ObservabilityPipelineAddMetricTagsProcessor, * ObservabilityPipelineAggregateProcessor, ObservabilityPipelineMetricEnrichmentTableProcessor, * ObservabilityPipelineMetricTagsProcessor, ObservabilityPipelineRenameMetricTagsProcessor, @@ -1920,6 +1981,11 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + ObservabilityPipelineSpikeProtectionProcessor.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf( ObservabilityPipelineSplitArrayProcessor.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -1983,6 +2049,7 @@ public void setActualInstance(Object instance) { + " ObservabilityPipelineRemoveFieldsProcessor," + " ObservabilityPipelineRenameFieldsProcessor, ObservabilityPipelineSampleProcessor," + " ObservabilityPipelineSensitiveDataScannerProcessor," + + " ObservabilityPipelineSpikeProtectionProcessor," + " ObservabilityPipelineSplitArrayProcessor, ObservabilityPipelineThrottleProcessor," + " ObservabilityPipelineAddMetricTagsProcessor," + " ObservabilityPipelineAggregateProcessor," @@ -2003,7 +2070,8 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineParseXMLProcessor, ObservabilityPipelineQuotaProcessor, * ObservabilityPipelineReduceProcessor, ObservabilityPipelineRemoveFieldsProcessor, * ObservabilityPipelineRenameFieldsProcessor, ObservabilityPipelineSampleProcessor, - * ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineSplitArrayProcessor, + * ObservabilityPipelineSensitiveDataScannerProcessor, + * ObservabilityPipelineSpikeProtectionProcessor, ObservabilityPipelineSplitArrayProcessor, * ObservabilityPipelineThrottleProcessor, ObservabilityPipelineAddMetricTagsProcessor, * ObservabilityPipelineAggregateProcessor, ObservabilityPipelineMetricEnrichmentTableProcessor, * ObservabilityPipelineMetricTagsProcessor, ObservabilityPipelineRenameMetricTagsProcessor, @@ -2021,8 +2089,9 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineReduceProcessor, ObservabilityPipelineRemoveFieldsProcessor, * ObservabilityPipelineRenameFieldsProcessor, ObservabilityPipelineSampleProcessor, * ObservabilityPipelineSensitiveDataScannerProcessor, - * ObservabilityPipelineSplitArrayProcessor, ObservabilityPipelineThrottleProcessor, - * ObservabilityPipelineAddMetricTagsProcessor, ObservabilityPipelineAggregateProcessor, + * ObservabilityPipelineSpikeProtectionProcessor, ObservabilityPipelineSplitArrayProcessor, + * ObservabilityPipelineThrottleProcessor, ObservabilityPipelineAddMetricTagsProcessor, + * ObservabilityPipelineAggregateProcessor, * ObservabilityPipelineMetricEnrichmentTableProcessor, * ObservabilityPipelineMetricTagsProcessor, ObservabilityPipelineRenameMetricTagsProcessor, * ObservabilityPipelineTagCardinalityLimitProcessor) @@ -2280,6 +2349,20 @@ public ObservabilityPipelineSampleProcessor getObservabilityPipelineSampleProces return (ObservabilityPipelineSensitiveDataScannerProcessor) super.getActualInstance(); } + /** + * Get the actual instance of `ObservabilityPipelineSpikeProtectionProcessor`. If the actual + * instance is not `ObservabilityPipelineSpikeProtectionProcessor`, the ClassCastException will be + * thrown. + * + * @return The actual instance of `ObservabilityPipelineSpikeProtectionProcessor` + * @throws ClassCastException if the instance is not + * `ObservabilityPipelineSpikeProtectionProcessor` + */ + public ObservabilityPipelineSpikeProtectionProcessor + getObservabilityPipelineSpikeProtectionProcessor() throws ClassCastException { + return (ObservabilityPipelineSpikeProtectionProcessor) super.getActualInstance(); + } + /** * Get the actual instance of `ObservabilityPipelineSplitArrayProcessor`. If the actual instance * is not `ObservabilityPipelineSplitArrayProcessor`, the ClassCastException will be thrown. diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessor.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessor.java new file mode 100644 index 00000000000..02e1ada2f71 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessor.java @@ -0,0 +1,564 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** + * The spike_protection processor learns the normal ingestion volume for the logs that + * match a specified filter and takes action when the volume spikes unexpectedly. + * + *

Supported pipeline types: logs + */ +@JsonPropertyOrder({ + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_ACTION_WHEN_MISSING_PARTITIONS, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_DISPLAY_NAME, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_ENABLED, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_ID, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_INCLUDE, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_MINIMAL_THRESHOLD, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_MINIMAL_THRESHOLD_OVERRIDES, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_NAME, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_PARTITION_FIELDS, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_SPIKE_ACTION, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_SPIKE_THRESHOLD, + ObservabilityPipelineSpikeProtectionProcessor.JSON_PROPERTY_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineSpikeProtectionProcessor { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ACTION_WHEN_MISSING_PARTITIONS = + "action_when_missing_partitions"; + private ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + actionWhenMissingPartitions = + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions.IGNORE; + + public static final String JSON_PROPERTY_DISPLAY_NAME = "display_name"; + private String displayName; + + public static final String JSON_PROPERTY_ENABLED = "enabled"; + private Boolean enabled; + + public static final String JSON_PROPERTY_ID = "id"; + private String id; + + public static final String JSON_PROPERTY_INCLUDE = "include"; + private String include; + + public static final String JSON_PROPERTY_MINIMAL_THRESHOLD = "minimal_threshold"; + private Long minimalThreshold; + + public static final String JSON_PROPERTY_MINIMAL_THRESHOLD_OVERRIDES = + "minimal_threshold_overrides"; + private List + minimalThresholdOverrides = null; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public static final String JSON_PROPERTY_PARTITION_FIELDS = "partition_fields"; + private List partitionFields = null; + + public static final String JSON_PROPERTY_SPIKE_ACTION = "spike_action"; + private ObservabilityPipelineSpikeProtectionProcessorSpikeAction spikeAction; + + public static final String JSON_PROPERTY_SPIKE_THRESHOLD = "spike_threshold"; + private Double spikeThreshold; + + public static final String JSON_PROPERTY_TYPE = "type"; + private ObservabilityPipelineSpikeProtectionProcessorType type = + ObservabilityPipelineSpikeProtectionProcessorType.SPIKE_PROTECTION; + + public ObservabilityPipelineSpikeProtectionProcessor() {} + + @JsonCreator + public ObservabilityPipelineSpikeProtectionProcessor( + @JsonProperty(required = true, value = JSON_PROPERTY_ENABLED) Boolean enabled, + @JsonProperty(required = true, value = JSON_PROPERTY_ID) String id, + @JsonProperty(required = true, value = JSON_PROPERTY_INCLUDE) String include, + @JsonProperty(required = true, value = JSON_PROPERTY_NAME) String name, + @JsonProperty(required = true, value = JSON_PROPERTY_SPIKE_ACTION) + ObservabilityPipelineSpikeProtectionProcessorSpikeAction spikeAction, + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + ObservabilityPipelineSpikeProtectionProcessorType type) { + this.enabled = enabled; + this.id = id; + this.include = include; + this.name = name; + this.spikeAction = spikeAction; + this.unparsed |= !spikeAction.isValid(); + this.type = type; + this.unparsed |= !type.isValid(); + } + + public ObservabilityPipelineSpikeProtectionProcessor actionWhenMissingPartitions( + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + actionWhenMissingPartitions) { + this.actionWhenMissingPartitions = actionWhenMissingPartitions; + this.unparsed |= !actionWhenMissingPartitions.isValid(); + return this; + } + + /** + * How to handle logs that are missing one of the partition_fields. Options: - + * ignore: Forward the event without applying spike protection. - default_bucket + * : Assign the event to a default partition. + * + * @return actionWhenMissingPartitions + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ACTION_WHEN_MISSING_PARTITIONS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + getActionWhenMissingPartitions() { + return actionWhenMissingPartitions; + } + + public void setActionWhenMissingPartitions( + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + actionWhenMissingPartitions) { + if (!actionWhenMissingPartitions.isValid()) { + this.unparsed = true; + } + this.actionWhenMissingPartitions = actionWhenMissingPartitions; + } + + public ObservabilityPipelineSpikeProtectionProcessor displayName(String displayName) { + this.displayName = displayName; + return this; + } + + /** + * The display name for a component. + * + * @return displayName + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_DISPLAY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getDisplayName() { + return displayName; + } + + public void setDisplayName(String displayName) { + this.displayName = displayName; + } + + public ObservabilityPipelineSpikeProtectionProcessor enabled(Boolean enabled) { + this.enabled = enabled; + return this; + } + + /** + * Indicates whether the processor is enabled. + * + * @return enabled + */ + @JsonProperty(JSON_PROPERTY_ENABLED) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public Boolean getEnabled() { + return enabled; + } + + public void setEnabled(Boolean enabled) { + this.enabled = enabled; + } + + public ObservabilityPipelineSpikeProtectionProcessor id(String id) { + this.id = id; + return this; + } + + /** + * 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). + * + * @return id + */ + @JsonProperty(JSON_PROPERTY_ID) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public ObservabilityPipelineSpikeProtectionProcessor include(String include) { + this.include = include; + return this; + } + + /** + * A Datadog search query used to determine which logs this processor targets. + * + * @return include + */ + @JsonProperty(JSON_PROPERTY_INCLUDE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getInclude() { + return include; + } + + public void setInclude(String include) { + this.include = include; + } + + public ObservabilityPipelineSpikeProtectionProcessor minimalThreshold(Long minimalThreshold) { + this.minimalThreshold = minimalThreshold; + return this; + } + + /** + * The minimum volume, in bytes, that must be observed within 24 hours before spike protection can + * activate. Defaults to 100 GiB. + * + * @return minimalThreshold + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MINIMAL_THRESHOLD) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getMinimalThreshold() { + return minimalThreshold; + } + + public void setMinimalThreshold(Long minimalThreshold) { + this.minimalThreshold = minimalThreshold; + } + + public ObservabilityPipelineSpikeProtectionProcessor minimalThresholdOverrides( + List + minimalThresholdOverrides) { + this.minimalThresholdOverrides = minimalThresholdOverrides; + if (minimalThresholdOverrides != null) { + for (ObservabilityPipelineSpikeProtectionProcessorThresholdOverride item : + minimalThresholdOverrides) { + this.unparsed |= item.unparsed; + } + } + return this; + } + + public ObservabilityPipelineSpikeProtectionProcessor addMinimalThresholdOverridesItem( + ObservabilityPipelineSpikeProtectionProcessorThresholdOverride + minimalThresholdOverridesItem) { + if (this.minimalThresholdOverrides == null) { + this.minimalThresholdOverrides = new ArrayList<>(); + } + this.minimalThresholdOverrides.add(minimalThresholdOverridesItem); + this.unparsed |= minimalThresholdOverridesItem.unparsed; + return this; + } + + /** + * A list of per-partition overrides for the minimal threshold, identified by matching field + * values. Requires partition_fields to be set. + * + * @return minimalThresholdOverrides + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MINIMAL_THRESHOLD_OVERRIDES) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List + getMinimalThresholdOverrides() { + return minimalThresholdOverrides; + } + + public void setMinimalThresholdOverrides( + List + minimalThresholdOverrides) { + this.minimalThresholdOverrides = minimalThresholdOverrides; + if (minimalThresholdOverrides != null) { + for (ObservabilityPipelineSpikeProtectionProcessorThresholdOverride item : + minimalThresholdOverrides) { + this.unparsed |= item.unparsed; + } + } + } + + public ObservabilityPipelineSpikeProtectionProcessor name(String name) { + this.name = name; + return this; + } + + /** + * Name of the spike protection rule. + * + * @return name + */ + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public ObservabilityPipelineSpikeProtectionProcessor partitionFields( + List partitionFields) { + this.partitionFields = partitionFields; + return this; + } + + public ObservabilityPipelineSpikeProtectionProcessor addPartitionFieldsItem( + String partitionFieldsItem) { + if (this.partitionFields == null) { + this.partitionFields = new ArrayList<>(); + } + this.partitionFields.add(partitionFieldsItem); + return this; + } + + /** + * A list of fields used to segment log traffic. Volume is learned and evaluated independently for + * each unique combination of these field values. A maximum of five fields is supported. + * + * @return partitionFields + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_PARTITION_FIELDS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getPartitionFields() { + return partitionFields; + } + + public void setPartitionFields(List partitionFields) { + this.partitionFields = partitionFields; + } + + public ObservabilityPipelineSpikeProtectionProcessor spikeAction( + ObservabilityPipelineSpikeProtectionProcessorSpikeAction spikeAction) { + this.spikeAction = spikeAction; + this.unparsed |= !spikeAction.isValid(); + return this; + } + + /** + * The action to take with matching logs while spike protection is active. Options: - drop + * : Drop the event. - no_action: Let the event pass through. - + * overflow_routing: Route to an overflow destination. + * + *

When overflow_routing is used, there must be a destination whose inputs + * reference this processor with the <processor-id>.overflow_events + * suffix to route the overflowing events. + * + * @return spikeAction + */ + @JsonProperty(JSON_PROPERTY_SPIKE_ACTION) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineSpikeProtectionProcessorSpikeAction getSpikeAction() { + return spikeAction; + } + + public void setSpikeAction(ObservabilityPipelineSpikeProtectionProcessorSpikeAction spikeAction) { + if (!spikeAction.isValid()) { + this.unparsed = true; + } + this.spikeAction = spikeAction; + } + + public ObservabilityPipelineSpikeProtectionProcessor spikeThreshold(Double spikeThreshold) { + this.spikeThreshold = spikeThreshold; + return this; + } + + /** + * The number of standard deviations above the learned mean volume that must be exceeded before a + * spike is detected. Defaults to 5. + * + * @return spikeThreshold + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_SPIKE_THRESHOLD) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Double getSpikeThreshold() { + return spikeThreshold; + } + + public void setSpikeThreshold(Double spikeThreshold) { + this.spikeThreshold = spikeThreshold; + } + + public ObservabilityPipelineSpikeProtectionProcessor type( + ObservabilityPipelineSpikeProtectionProcessorType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * The processor type. The value should always be spike_protection. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineSpikeProtectionProcessorType getType() { + return type; + } + + public void setType(ObservabilityPipelineSpikeProtectionProcessorType type) { + if (!type.isValid()) { + this.unparsed = true; + } + this.type = type; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return ObservabilityPipelineSpikeProtectionProcessor + */ + @JsonAnySetter + public ObservabilityPipelineSpikeProtectionProcessor putAdditionalProperty( + String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** Return true if this ObservabilityPipelineSpikeProtectionProcessor object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineSpikeProtectionProcessor observabilityPipelineSpikeProtectionProcessor = + (ObservabilityPipelineSpikeProtectionProcessor) o; + return Objects.equals( + this.actionWhenMissingPartitions, + observabilityPipelineSpikeProtectionProcessor.actionWhenMissingPartitions) + && Objects.equals( + this.displayName, observabilityPipelineSpikeProtectionProcessor.displayName) + && Objects.equals(this.enabled, observabilityPipelineSpikeProtectionProcessor.enabled) + && Objects.equals(this.id, observabilityPipelineSpikeProtectionProcessor.id) + && Objects.equals(this.include, observabilityPipelineSpikeProtectionProcessor.include) + && Objects.equals( + this.minimalThreshold, observabilityPipelineSpikeProtectionProcessor.minimalThreshold) + && Objects.equals( + this.minimalThresholdOverrides, + observabilityPipelineSpikeProtectionProcessor.minimalThresholdOverrides) + && Objects.equals(this.name, observabilityPipelineSpikeProtectionProcessor.name) + && Objects.equals( + this.partitionFields, observabilityPipelineSpikeProtectionProcessor.partitionFields) + && Objects.equals( + this.spikeAction, observabilityPipelineSpikeProtectionProcessor.spikeAction) + && Objects.equals( + this.spikeThreshold, observabilityPipelineSpikeProtectionProcessor.spikeThreshold) + && Objects.equals(this.type, observabilityPipelineSpikeProtectionProcessor.type) + && Objects.equals( + this.additionalProperties, + observabilityPipelineSpikeProtectionProcessor.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + actionWhenMissingPartitions, + displayName, + enabled, + id, + include, + minimalThreshold, + minimalThresholdOverrides, + name, + partitionFields, + spikeAction, + spikeThreshold, + type, + additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineSpikeProtectionProcessor {\n"); + sb.append(" actionWhenMissingPartitions: ") + .append(toIndentedString(actionWhenMissingPartitions)) + .append("\n"); + sb.append(" displayName: ").append(toIndentedString(displayName)).append("\n"); + sb.append(" enabled: ").append(toIndentedString(enabled)).append("\n"); + sb.append(" id: ").append(toIndentedString(id)).append("\n"); + sb.append(" include: ").append(toIndentedString(include)).append("\n"); + sb.append(" minimalThreshold: ").append(toIndentedString(minimalThreshold)).append("\n"); + sb.append(" minimalThresholdOverrides: ") + .append(toIndentedString(minimalThresholdOverrides)) + .append("\n"); + sb.append(" name: ").append(toIndentedString(name)).append("\n"); + sb.append(" partitionFields: ").append(toIndentedString(partitionFields)).append("\n"); + sb.append(" spikeAction: ").append(toIndentedString(spikeAction)).append("\n"); + sb.append(" spikeThreshold: ").append(toIndentedString(spikeThreshold)).append("\n"); + sb.append(" type: ").append(toIndentedString(type)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions.java new file mode 100644 index 00000000000..d71b56c3183 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions.java @@ -0,0 +1,77 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** + * How to handle logs that are missing one of the partition_fields. Options: - + * ignore: Forward the event without applying spike protection. - default_bucket + * : Assign the event to a default partition. + */ +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + .ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitionsSerializer + .class) +public class ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("ignore", "default_bucket")); + + public static final ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + IGNORE = + new ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions("ignore"); + public static final ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions + DEFAULT_BUCKET = + new ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions( + "default_bucket"); + + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions(String value) { + super(value, allowedValues); + } + + public static + class ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitionsSerializer + extends StdSerializer< + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions> { + public ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitionsSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitionsSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions fromValue( + String value) { + return new ObservabilityPipelineSpikeProtectionProcessorActionWhenMissingPartitions(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.java new file mode 100644 index 00000000000..8fefb24c6f7 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.java @@ -0,0 +1,381 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.AbstractOpenApiSchema; +import com.datadog.api.client.JSON; +import com.datadog.api.client.UnparsedObject; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import jakarta.ws.rs.core.GenericType; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +@JsonDeserialize( + using = + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold + .ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdDeserializer.class) +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold + .ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdSerializer.class) +public class ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold + extends AbstractOpenApiSchema { + private static final Logger log = + Logger.getLogger( + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.class.getName()); + + @JsonIgnore public boolean unparsed = false; + + public static class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdSerializer + extends StdSerializer { + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.getActualInstance()); + } + } + + public static class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdDeserializer + extends StdDeserializer { + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdDeserializer() { + this(ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.class); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdDeserializer(Class vc) { + super(vc); + } + + @Override + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold deserialize( + JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { + JsonNode tree = jp.readValueAsTree(); + Object deserialized = null; + Object tmp = null; + boolean typeCoercion = ctxt.isEnabled(MapperFeature.ALLOW_COERCION_OF_SCALARS); + int match = 0; + JsonToken token = tree.traverse(jp.getCodec()).nextToken(); + // deserialize ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Integer.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Long.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Float.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Double.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Boolean.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Integer.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class + .equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Float.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class + .equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class.equals( + String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class); + // TODO: there is no validation against JSON schema constraints + // (min, max, enum, pattern...), this does not perform a strict JSON + // validation, which means the 'match' count may be higher than it should be. + if (!((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes) tmp) + .unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema" + + " 'ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes'", + e); + } + + // deserialize ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + Integer.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + Long.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + Float.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + Double.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + Boolean.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class + .equals(Integer.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + .class + .equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class + .equals(Float.class) + || ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + .class + .equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class + .equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class + .equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + .class); + // TODO: there is no validation against JSON schema constraints + // (min, max, enum, pattern...), this does not perform a strict JSON + // validation, which means the 'match' count may be higher than it should be. + if (!((ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep) tmp) + .unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema" + + " 'ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep'", + e); + } + + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold ret = + new ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold(); + if (match == 1) { + ret.setActualInstance(deserialized); + } else { + Map res = + new ObjectMapper() + .readValue( + tree.traverse(jp.getCodec()).readValueAsTree().toString(), + new TypeReference>() {}); + ret.setActualInstance(new UnparsedObject(res)); + } + return ret; + } + + /** Handle deserialization of the 'null' value. */ + @Override + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold getNullValue( + DeserializationContext ctxt) throws JsonMappingException { + throw new JsonMappingException( + ctxt.getParser(), + "ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold cannot be null"); + } + } + + // store a list of schema names defined in oneOf + public static final Map schemas = new HashMap(); + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold() { + super("oneOf", Boolean.FALSE); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + static { + schemas.put( + "ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes", + new GenericType() {}); + schemas.put( + "ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep", + new GenericType< + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep>() {}); + JSON.registerDescendants( + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.class, + Collections.unmodifiableMap(schemas)); + } + + @Override + public Map getSchemas() { + return ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold.schemas; + } + + /** + * Set the instance that matches the oneOf child schema, check the instance parameter is valid + * against the oneOf child schemas: + * ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes, + * ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + * + *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a + * composed schema (allOf, anyOf, oneOf). + */ + @Override + public void setActualInstance(Object instance) { + if (JSON.isInstanceOf( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + + if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + throw new RuntimeException( + "Invalid instance type. Must be" + + " ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes," + + " ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep"); + } + + /** + * Get the actual instance, which can be the following: + * ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes, + * ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + * + * @return The actual instance + * (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes, + * ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep) + */ + @Override + public Object getActualInstance() { + return super.getActualInstance(); + } + + /** + * Get the actual instance of + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes`. If the actual instance is + * not `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes`, the + * ClassCastException will be thrown. + * + * @return The actual instance of + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes` + * @throws ClassCastException if the instance is not + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes` + */ + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes + getObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes() + throws ClassCastException { + return (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes) + super.getActualInstance(); + } + + /** + * Get the actual instance of + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep`. If the actual + * instance is not `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep`, the + * ClassCastException will be thrown. + * + * @return The actual instance of + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep` + * @throws ClassCastException if the instance is not + * `ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep` + */ + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + getObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep() + throws ClassCastException { + return (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep) + super.getActualInstance(); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.java new file mode 100644 index 00000000000..bb6ad3762ee --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.java @@ -0,0 +1,164 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** Never activates spike protection for the matching partition, regardless of volume. */ +@JsonPropertyOrder({ + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.JSON_PROPERTY_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_TYPE = "type"; + private ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType type = + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType.ALWAYS_KEEP; + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep() {} + + @JsonCreator + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep( + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType type) { + this.type = type; + this.unparsed |= !type.isValid(); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep type( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * The minimal threshold type. The value should always be always_keep. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType getType() { + return type; + } + + public void setType( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType type) { + if (!type.isValid()) { + this.unparsed = true; + } + this.type = type; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + */ + @JsonAnySetter + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + putAdditionalProperty(String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** + * Return true if this ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + * object is equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + observabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep = + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep) o; + return Objects.equals( + this.type, observabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep.type) + && Objects.equals( + this.additionalProperties, + observabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep + .additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(type, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeep {\n"); + sb.append(" type: ").append(toIndentedString(type)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType.java new file mode 100644 index 00000000000..5ea5417b61c --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType.java @@ -0,0 +1,70 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** The minimal threshold type. The value should always be always_keep. */ +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType + .ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepTypeSerializer + .class) +public class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType + extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("always_keep")); + + public static final ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType + ALWAYS_KEEP = + new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType( + "always_keep"); + + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType(String value) { + super(value, allowedValues); + } + + public static + class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepTypeSerializer + extends StdSerializer< + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType> { + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepTypeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepTypeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType + fromValue(String value) { + return new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdAlwaysKeepType(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.java new file mode 100644 index 00000000000..a52726c43df --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.java @@ -0,0 +1,192 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** Sets a specific byte threshold for the matching partition. */ +@JsonPropertyOrder({ + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.JSON_PROPERTY_BYTES, + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.JSON_PROPERTY_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_BYTES = "bytes"; + private Long bytes; + + public static final String JSON_PROPERTY_TYPE = "type"; + private ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType type = + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType.THRESHOLD; + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes() {} + + @JsonCreator + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes( + @JsonProperty(required = true, value = JSON_PROPERTY_BYTES) Long bytes, + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType type) { + this.bytes = bytes; + this.type = type; + this.unparsed |= !type.isValid(); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes bytes(Long bytes) { + this.bytes = bytes; + return this; + } + + /** + * The minimal threshold, in bytes, for the matching partition. + * + * @return bytes + */ + @JsonProperty(JSON_PROPERTY_BYTES) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public Long getBytes() { + return bytes; + } + + public void setBytes(Long bytes) { + this.bytes = bytes; + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes type( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * The minimal threshold type. The value should always be threshold. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType getType() { + return type; + } + + public void setType(ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType type) { + if (!type.isValid()) { + this.unparsed = true; + } + this.type = type; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes + */ + @JsonAnySetter + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes putAdditionalProperty( + String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** + * Return true if this ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes object + * is equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes + observabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes = + (ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes) o; + return Objects.equals( + this.bytes, observabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.bytes) + && Objects.equals( + this.type, observabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes.type) + && Objects.equals( + this.additionalProperties, + observabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes + .additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(bytes, type, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytes {\n"); + sb.append(" bytes: ").append(toIndentedString(bytes)).append("\n"); + sb.append(" type: ").append(toIndentedString(type)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType.java new file mode 100644 index 00000000000..6e6625bd5e8 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType.java @@ -0,0 +1,67 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** The minimal threshold type. The value should always be threshold. */ +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType + .ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesTypeSerializer.class) +public class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType + extends ModelEnum { + + private static final Set allowedValues = new HashSet(Arrays.asList("threshold")); + + public static final ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType + THRESHOLD = + new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType("threshold"); + + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType(String value) { + super(value, allowedValues); + } + + public static + class ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesTypeSerializer + extends StdSerializer< + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType> { + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesTypeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesTypeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType fromValue( + String value) { + return new ObservabilityPipelineSpikeProtectionProcessorMinimalThresholdBytesType(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorSpikeAction.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorSpikeAction.java new file mode 100644 index 00000000000..749e196c8c8 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorSpikeAction.java @@ -0,0 +1,75 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** + * The action to take with matching logs while spike protection is active. Options: - drop + * : Drop the event. - no_action: Let the event pass through. - + * overflow_routing: Route to an overflow destination. + * + *

When overflow_routing is used, there must be a destination whose inputs + * reference this processor with the <processor-id>.overflow_events + * suffix to route the overflowing events. + */ +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorSpikeAction + .ObservabilityPipelineSpikeProtectionProcessorSpikeActionSerializer.class) +public class ObservabilityPipelineSpikeProtectionProcessorSpikeAction extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("drop", "no_action", "overflow_routing")); + + public static final ObservabilityPipelineSpikeProtectionProcessorSpikeAction DROP = + new ObservabilityPipelineSpikeProtectionProcessorSpikeAction("drop"); + public static final ObservabilityPipelineSpikeProtectionProcessorSpikeAction NO_ACTION = + new ObservabilityPipelineSpikeProtectionProcessorSpikeAction("no_action"); + public static final ObservabilityPipelineSpikeProtectionProcessorSpikeAction OVERFLOW_ROUTING = + new ObservabilityPipelineSpikeProtectionProcessorSpikeAction("overflow_routing"); + + ObservabilityPipelineSpikeProtectionProcessorSpikeAction(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineSpikeProtectionProcessorSpikeActionSerializer + extends StdSerializer { + public ObservabilityPipelineSpikeProtectionProcessorSpikeActionSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorSpikeActionSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorSpikeAction value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSpikeProtectionProcessorSpikeAction fromValue(String value) { + return new ObservabilityPipelineSpikeProtectionProcessorSpikeAction(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorThresholdOverride.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorThresholdOverride.java new file mode 100644 index 00000000000..53a8a1fc844 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorThresholdOverride.java @@ -0,0 +1,218 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** + * Defines a minimal threshold that applies to a specific partition instead of the processor-wide + * minimal_threshold. + */ +@JsonPropertyOrder({ + ObservabilityPipelineSpikeProtectionProcessorThresholdOverride.JSON_PROPERTY_FIELDS, + ObservabilityPipelineSpikeProtectionProcessorThresholdOverride.JSON_PROPERTY_MINIMAL_THRESHOLD +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineSpikeProtectionProcessorThresholdOverride { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_FIELDS = "fields"; + private List fields = new ArrayList<>(); + + public static final String JSON_PROPERTY_MINIMAL_THRESHOLD = "minimal_threshold"; + private ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold minimalThreshold; + + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride() {} + + @JsonCreator + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride( + @JsonProperty(required = true, value = JSON_PROPERTY_FIELDS) + List fields, + @JsonProperty(required = true, value = JSON_PROPERTY_MINIMAL_THRESHOLD) + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold minimalThreshold) { + this.fields = fields; + for (ObservabilityPipelineFieldValue item : fields) { + this.unparsed |= item.unparsed; + } + this.minimalThreshold = minimalThreshold; + this.unparsed |= minimalThreshold.unparsed; + } + + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride fields( + List fields) { + this.fields = fields; + for (ObservabilityPipelineFieldValue item : fields) { + this.unparsed |= item.unparsed; + } + return this; + } + + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride addFieldsItem( + ObservabilityPipelineFieldValue fieldsItem) { + this.fields.add(fieldsItem); + this.unparsed |= fieldsItem.unparsed; + return this; + } + + /** + * The set of field matchers that identifies the partition this override applies to. Every field + * name listed must also appear in partition_fields. + * + * @return fields + */ + @JsonProperty(JSON_PROPERTY_FIELDS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getFields() { + return fields; + } + + public void setFields(List fields) { + this.fields = fields; + if (fields != null) { + for (ObservabilityPipelineFieldValue item : fields) { + this.unparsed |= item.unparsed; + } + } + } + + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride minimalThreshold( + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold minimalThreshold) { + this.minimalThreshold = minimalThreshold; + this.unparsed |= minimalThreshold.unparsed; + return this; + } + + /** + * The minimal threshold to apply to the matching partition. + * + * @return minimalThreshold + */ + @JsonProperty(JSON_PROPERTY_MINIMAL_THRESHOLD) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold getMinimalThreshold() { + return minimalThreshold; + } + + public void setMinimalThreshold( + ObservabilityPipelineSpikeProtectionProcessorMinimalThreshold minimalThreshold) { + this.minimalThreshold = minimalThreshold; + if (minimalThreshold != null) { + this.unparsed |= minimalThreshold.unparsed; + } + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return ObservabilityPipelineSpikeProtectionProcessorThresholdOverride + */ + @JsonAnySetter + public ObservabilityPipelineSpikeProtectionProcessorThresholdOverride putAdditionalProperty( + String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** + * Return true if this ObservabilityPipelineSpikeProtectionProcessorThresholdOverride object is + * equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineSpikeProtectionProcessorThresholdOverride + observabilityPipelineSpikeProtectionProcessorThresholdOverride = + (ObservabilityPipelineSpikeProtectionProcessorThresholdOverride) o; + return Objects.equals( + this.fields, observabilityPipelineSpikeProtectionProcessorThresholdOverride.fields) + && Objects.equals( + this.minimalThreshold, + observabilityPipelineSpikeProtectionProcessorThresholdOverride.minimalThreshold) + && Objects.equals( + this.additionalProperties, + observabilityPipelineSpikeProtectionProcessorThresholdOverride.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(fields, minimalThreshold, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineSpikeProtectionProcessorThresholdOverride {\n"); + sb.append(" fields: ").append(toIndentedString(fields)).append("\n"); + sb.append(" minimalThreshold: ").append(toIndentedString(minimalThreshold)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorType.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorType.java new file mode 100644 index 00000000000..77c6596d204 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSpikeProtectionProcessorType.java @@ -0,0 +1,63 @@ +/* + * 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. + */ + +package com.datadog.api.client.v2.model; + +import com.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** The processor type. The value should always be spike_protection. */ +@JsonSerialize( + using = + ObservabilityPipelineSpikeProtectionProcessorType + .ObservabilityPipelineSpikeProtectionProcessorTypeSerializer.class) +public class ObservabilityPipelineSpikeProtectionProcessorType extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("spike_protection")); + + public static final ObservabilityPipelineSpikeProtectionProcessorType SPIKE_PROTECTION = + new ObservabilityPipelineSpikeProtectionProcessorType("spike_protection"); + + ObservabilityPipelineSpikeProtectionProcessorType(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineSpikeProtectionProcessorTypeSerializer + extends StdSerializer { + public ObservabilityPipelineSpikeProtectionProcessorTypeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSpikeProtectionProcessorTypeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSpikeProtectionProcessorType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSpikeProtectionProcessorType fromValue(String value) { + return new ObservabilityPipelineSpikeProtectionProcessorType(value); + } +} diff --git a/src/test/resources/com/datadog/api/client/v2/api/observability_pipelines.feature b/src/test/resources/com/datadog/api/client/v2/api/observability_pipelines.feature index 261e6f4bd6e..09472e4ecbd 100644 --- a/src/test/resources/com/datadog/api/client/v2/api/observability_pipelines.feature +++ b/src/test/resources/com/datadog/api/client/v2/api/observability_pipelines.feature @@ -351,6 +351,22 @@ Feature: Observability Pipelines Then the response status is 200 OK And the response "errors" has length 0 + @team:ddoghq/observability-pipelines + Scenario: Validate an observability pipeline with spike protection processor returns "OK" response + Given new "ValidatePipeline" request + And body with value {"data": {"attributes": {"config": {"destinations": [{"id": "datadog-logs-destination", "inputs": ["my-processor-group"], "type": "datadog_logs"}], "processor_groups": [{"enabled": true, "id": "my-processor-group", "include": "service:my-service", "inputs": ["datadog-agent-source"], "processors": [{"enabled": true, "id": "spike-protection-processor", "include": "*", "type": "spike_protection", "name": "MySpikeProtection", "spike_action": "drop", "spike_threshold": 5, "minimal_threshold": 107374182400}]}], "sources": [{"id": "datadog-agent-source", "type": "datadog_agent"}]}, "name": "Pipeline with Spike Protection"}, "type": "pipelines"}} + When the request is sent + Then the response status is 200 OK + And the response "errors" has length 0 + + @team:ddoghq/observability-pipelines + Scenario: Validate an observability pipeline with spike protection processor threshold overrides returns "OK" response + Given new "ValidatePipeline" request + And body with value {"data": {"attributes": {"config": {"destinations": [{"id": "datadog-logs-destination", "inputs": ["my-processor-group"], "type": "datadog_logs"}], "processor_groups": [{"enabled": true, "id": "my-processor-group", "include": "service:my-service", "inputs": ["datadog-agent-source"], "processors": [{"enabled": true, "id": "spike-protection-processor", "include": "*", "type": "spike_protection", "name": "MyPartitionedSpikeProtection", "spike_action": "no_action", "partition_fields": ["service"], "action_when_missing_partitions": "default_bucket", "minimal_threshold_overrides": [{"fields": [{"name": "service", "value": "checkout"}], "minimal_threshold": {"type": "threshold", "bytes": 53687091200}}, {"fields": [{"name": "service", "value": "payments"}], "minimal_threshold": {"type": "always_keep"}}]}]}], "sources": [{"id": "datadog-agent-source", "type": "datadog_agent"}]}, "name": "Pipeline with Spike Protection Threshold Overrides"}, "type": "pipelines"}} + When the request is sent + Then the response status is 200 OK + And the response "errors" has length 0 + @team:ddoghq/observability-pipelines Scenario: Validate an observability pipeline with websocket source bearer auth returns "OK" response Given new "ValidatePipeline" request diff --git a/src/test/resources/generated-test/test-runner-data/manifest.json b/src/test/resources/generated-test/test-runner-data/manifest.json index a38c39c816d..0867d8aa042 100644 --- a/src/test/resources/generated-test/test-runner-data/manifest.json +++ b/src/test/resources/generated-test/test-runner-data/manifest.json @@ -8827,6 +8827,20 @@ "scenario": "Validate an observability pipeline with source secret key returns \"OK\" response", "version": "v2" }, + { + "feature": "Observability Pipelines", + "feature_file": "../../com/datadog/api/client/v2/api/observability_pipelines.feature", + "file": "v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-returns-ok-response.json", + "scenario": "Validate an observability pipeline with spike protection processor returns \"OK\" response", + "version": "v2" + }, + { + "feature": "Observability Pipelines", + "feature_file": "../../com/datadog/api/client/v2/api/observability_pipelines.feature", + "file": "v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-threshold-overrides-returns-ok-response.json", + "scenario": "Validate an observability pipeline with spike protection processor threshold overrides returns \"OK\" response", + "version": "v2" + }, { "feature": "Observability Pipelines", "feature_file": "../../com/datadog/api/client/v2/api/observability_pipelines.feature", diff --git a/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-returns-ok-response.json new file mode 100644 index 00000000000..34802ba881f --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-returns-ok-response.json @@ -0,0 +1,72 @@ +{ + "api": "ObservabilityPipelines", + "expected_status": 200, + "feature": "Observability Pipelines", + "id": "v2/Observability Pipelines/Validate an observability pipeline with spike protection processor returns \"OK\" response", + "operation_id": "ValidatePipeline", + "request": { + "body": { + "schema": { + "format": null, + "ref": "ObservabilityPipelineSpec", + "type": "object" + }, + "source": "inline", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "id": "datadog-logs-destination", + "inputs": [ + "my-processor-group" + ], + "type": "datadog_logs" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "enabled": true, + "id": "spike-protection-processor", + "include": "*", + "minimal_threshold": 107374182400, + "name": "MySpikeProtection", + "spike_action": "drop", + "spike_threshold": 5, + "type": "spike_protection" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Spike Protection" + }, + "type": "pipelines" + } + } + }, + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v2/obs-pipelines/pipelines/validate" + }, + "scenario": "Validate an observability pipeline with spike protection processor returns \"OK\" response", + "schema_version": 1, + "version": "v2" +} diff --git a/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-threshold-overrides-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-threshold-overrides-returns-ok-response.json new file mode 100644 index 00000000000..146fd075269 --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-spike-protection-processor-threshold-overrides-returns-ok-response.json @@ -0,0 +1,99 @@ +{ + "api": "ObservabilityPipelines", + "expected_status": 200, + "feature": "Observability Pipelines", + "id": "v2/Observability Pipelines/Validate an observability pipeline with spike protection processor threshold overrides returns \"OK\" response", + "operation_id": "ValidatePipeline", + "request": { + "body": { + "schema": { + "format": null, + "ref": "ObservabilityPipelineSpec", + "type": "object" + }, + "source": "inline", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "id": "datadog-logs-destination", + "inputs": [ + "my-processor-group" + ], + "type": "datadog_logs" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "action_when_missing_partitions": "default_bucket", + "enabled": true, + "id": "spike-protection-processor", + "include": "*", + "minimal_threshold_overrides": [ + { + "fields": [ + { + "name": "service", + "value": "checkout" + } + ], + "minimal_threshold": { + "bytes": 53687091200, + "type": "threshold" + } + }, + { + "fields": [ + { + "name": "service", + "value": "payments" + } + ], + "minimal_threshold": { + "type": "always_keep" + } + } + ], + "name": "MyPartitionedSpikeProtection", + "partition_fields": [ + "service" + ], + "spike_action": "no_action", + "type": "spike_protection" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Spike Protection Threshold Overrides" + }, + "type": "pipelines" + } + } + }, + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v2/obs-pipelines/pipelines/validate" + }, + "scenario": "Validate an observability pipeline with spike protection processor threshold overrides returns \"OK\" response", + "schema_version": 1, + "version": "v2" +} diff --git a/src/test/resources/generated-test/test-server-data/v2/observability-pipelines.json b/src/test/resources/generated-test/test-server-data/v2/observability-pipelines.json index 5211f2b1d1a..17a9a68dec3 100644 --- a/src/test/resources/generated-test/test-server-data/v2/observability-pipelines.json +++ b/src/test/resources/generated-test/test-server-data/v2/observability-pipelines.json @@ -3296,6 +3296,187 @@ "scenario": "Validate an observability pipeline with source secret key returns \"OK\" response", "version": "v2" }, + { + "feature": "Observability Pipelines", + "frozen_at": "2026-10-21T09:12:44.167Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "id": "datadog-logs-destination", + "inputs": [ + "my-processor-group" + ], + "type": "datadog_logs" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "enabled": true, + "id": "spike-protection-processor", + "include": "*", + "minimal_threshold": 107374182400, + "name": "MySpikeProtection", + "spike_action": "drop", + "spike_threshold": 5, + "type": "spike_protection" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Spike Protection" + }, + "type": "pipelines" + } + } + }, + "content_type": "application/json", + "method": "POST", + "path": "/api/v2/obs-pipelines/pipelines/validate", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"errors\":[]}\n" + }, + "headers": { + "content-type": "application/vnd.api+json" + }, + "reason": "OK", + "status": 200 + } + } + ], + "scenario": "Validate an observability pipeline with spike protection processor returns \"OK\" response", + "version": "v2" + }, + { + "feature": "Observability Pipelines", + "frozen_at": "2026-10-21T09:12:44.469Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "id": "datadog-logs-destination", + "inputs": [ + "my-processor-group" + ], + "type": "datadog_logs" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "action_when_missing_partitions": "default_bucket", + "enabled": true, + "id": "spike-protection-processor", + "include": "*", + "minimal_threshold_overrides": [ + { + "fields": [ + { + "name": "service", + "value": "checkout" + } + ], + "minimal_threshold": { + "bytes": 53687091200, + "type": "threshold" + } + }, + { + "fields": [ + { + "name": "service", + "value": "payments" + } + ], + "minimal_threshold": { + "type": "always_keep" + } + } + ], + "name": "MyPartitionedSpikeProtection", + "partition_fields": [ + "service" + ], + "spike_action": "no_action", + "type": "spike_protection" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Spike Protection Threshold Overrides" + }, + "type": "pipelines" + } + } + }, + "content_type": "application/json", + "method": "POST", + "path": "/api/v2/obs-pipelines/pipelines/validate", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"errors\":[]}\n" + }, + "headers": { + "content-type": "application/vnd.api+json" + }, + "reason": "OK", + "status": 200 + } + } + ], + "scenario": "Validate an observability pipeline with spike protection processor threshold overrides returns \"OK\" response", + "version": "v2" + }, { "feature": "Observability Pipelines", "frozen_at": "2026-06-22T19:51:31.598Z",