From 77548823383ecde3603f3063196ef52da61b4433 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Wed, 26 Aug 2026 08:32:01 +0000 Subject: [PATCH] Regenerate client from commit c789678 of spec repo --- .generator/schemas/v2/openapi.yaml | 13 +++ .../ValidatePipeline_1874470273.java | 94 +++++++++++++++++++ ...rvabilityPipelineSplunkHecDestination.java | 41 +++++++- ...ineSplunkHecDestinationEndpointTarget.java | 69 ++++++++++++++ .../v2/api/observability_pipelines.feature | 8 ++ .../test-runner-data/manifest.json | 7 ++ ...n-endpoint-target-returns-ok-response.json | 70 ++++++++++++++ .../v2/observability-pipelines.json | 75 +++++++++++++++ 8 files changed, 376 insertions(+), 1 deletion(-) create mode 100644 examples/v2/observability-pipelines/ValidatePipeline_1874470273.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestinationEndpointTarget.java create mode 100644 src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-splunk-hec-destination-endpoint-target-returns-ok-response.json diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index e24a358f1bd..7526650acd5 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -76438,12 +76438,15 @@ components: description: |- If `true`, Splunk tries to extract timestamps from incoming log events. If `false`, Splunk assigns the time the event was received. + Only applies when `endpoint_target` is `event`; cannot be `true` when `endpoint_target` is `raw`. example: true type: boolean buffer: $ref: "#/components/schemas/ObservabilityPipelineBufferOptions" encoding: $ref: "#/components/schemas/ObservabilityPipelineSplunkHecDestinationEncoding" + endpoint_target: + $ref: "#/components/schemas/ObservabilityPipelineSplunkHecDestinationEndpointTarget" endpoint_url_key: description: Name of the environment variable or secret that holds the Splunk HEC endpoint URL. example: SPLUNK_HEC_ENDPOINT_URL @@ -76498,6 +76501,16 @@ components: x-enum-varnames: - JSON - RAW_MESSAGE + ObservabilityPipelineSplunkHecDestinationEndpointTarget: + description: The Splunk HEC endpoint to send events to. Use `event` to send structured events to the `/event` endpoint, or `raw` to send the raw message to the `/raw` endpoint. + enum: + - event + - raw + example: event + type: string + x-enum-varnames: + - EVENT + - RAW ObservabilityPipelineSplunkHecDestinationTokenStrategy: description: Controls how the Splunk HEC token is supplied. Use `custom` to provide a token with `token_key`, or `from_source` to forward the token received from an upstream Splunk HEC source. enum: diff --git a/examples/v2/observability-pipelines/ValidatePipeline_1874470273.java b/examples/v2/observability-pipelines/ValidatePipeline_1874470273.java new file mode 100644 index 00000000000..d5c97b5e59b --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_1874470273.java @@ -0,0 +1,94 @@ +// Validate an observability pipeline with Splunk HEC destination endpoint_target 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.ObservabilityPipelineFilterProcessor; +import com.datadog.api.client.v2.model.ObservabilityPipelineFilterProcessorType; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpec; +import com.datadog.api.client.v2.model.ObservabilityPipelineSpecData; +import com.datadog.api.client.v2.model.ObservabilityPipelineSplunkHecDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineSplunkHecDestinationEndpointTarget; +import com.datadog.api.client.v2.model.ObservabilityPipelineSplunkHecDestinationType; +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(); + ObservabilityPipelinesApi apiInstance = new ObservabilityPipelinesApi(defaultClient); + + ObservabilityPipelineSpec body = + new ObservabilityPipelineSpec() + .data( + new ObservabilityPipelineSpecData() + .attributes( + new ObservabilityPipelineDataAttributes() + .config( + new ObservabilityPipelineConfig() + .destinations( + Collections.singletonList( + new ObservabilityPipelineConfigDestinationItem( + new ObservabilityPipelineSplunkHecDestination() + .id("splunk-hec-destination") + .inputs( + Collections.singletonList( + "my-processor-group")) + .type( + ObservabilityPipelineSplunkHecDestinationType + .SPLUNK_HEC) + .tokenKey("SPLUNK_HEC_TOKEN") + .endpointTarget( + ObservabilityPipelineSplunkHecDestinationEndpointTarget + .RAW)))) + .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 ObservabilityPipelineFilterProcessor() + .enabled(true) + .id("filter-processor") + .include("status:error") + .type( + ObservabilityPipelineFilterProcessorType + .FILTER)))))) + .sources( + Collections.singletonList( + new ObservabilityPipelineConfigSourceItem( + new ObservabilityPipelineDatadogAgentSource() + .id("datadog-agent-source") + .type( + ObservabilityPipelineDatadogAgentSourceType + .DATADOG_AGENT))))) + .name("Pipeline with Splunk HEC endpoint_target")) + .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/ObservabilityPipelineSplunkHecDestination.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestination.java index 0648559ffe4..7ea0d23ec76 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestination.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestination.java @@ -29,6 +29,7 @@ ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_AUTO_EXTRACT_TIMESTAMP, ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_BUFFER, ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_ENCODING, + ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_ENDPOINT_TARGET, ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_ENDPOINT_URL_KEY, ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_ID, ObservabilityPipelineSplunkHecDestination.JSON_PROPERTY_INDEX, @@ -52,6 +53,9 @@ public class ObservabilityPipelineSplunkHecDestination { public static final String JSON_PROPERTY_ENCODING = "encoding"; private ObservabilityPipelineSplunkHecDestinationEncoding encoding; + public static final String JSON_PROPERTY_ENDPOINT_TARGET = "endpoint_target"; + private ObservabilityPipelineSplunkHecDestinationEndpointTarget endpointTarget; + public static final String JSON_PROPERTY_ENDPOINT_URL_KEY = "endpoint_url_key"; private String endpointUrlKey; @@ -102,7 +106,9 @@ public ObservabilityPipelineSplunkHecDestination autoExtractTimestamp( /** * If true, Splunk tries to extract timestamps from incoming log events. If - * false, Splunk assigns the time the event was received. + * false, Splunk assigns the time the event was received. Only applies when + * endpoint_target is event; cannot be true when + * endpoint_target is raw. * * @return autoExtractTimestamp */ @@ -169,6 +175,35 @@ public void setEncoding(ObservabilityPipelineSplunkHecDestinationEncoding encodi this.encoding = encoding; } + public ObservabilityPipelineSplunkHecDestination endpointTarget( + ObservabilityPipelineSplunkHecDestinationEndpointTarget endpointTarget) { + this.endpointTarget = endpointTarget; + this.unparsed |= !endpointTarget.isValid(); + return this; + } + + /** + * The Splunk HEC endpoint to send events to. Use event to send structured events to + * the /event endpoint, or raw to send the raw message to the /raw + * endpoint. + * + * @return endpointTarget + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ENDPOINT_TARGET) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineSplunkHecDestinationEndpointTarget getEndpointTarget() { + return endpointTarget; + } + + public void setEndpointTarget( + ObservabilityPipelineSplunkHecDestinationEndpointTarget endpointTarget) { + if (!endpointTarget.isValid()) { + this.unparsed = true; + } + this.endpointTarget = endpointTarget; + } + public ObservabilityPipelineSplunkHecDestination endpointUrlKey(String endpointUrlKey) { this.endpointUrlKey = endpointUrlKey; return this; @@ -445,6 +480,8 @@ public boolean equals(Object o) { observabilityPipelineSplunkHecDestination.autoExtractTimestamp) && Objects.equals(this.buffer, observabilityPipelineSplunkHecDestination.buffer) && Objects.equals(this.encoding, observabilityPipelineSplunkHecDestination.encoding) + && Objects.equals( + this.endpointTarget, observabilityPipelineSplunkHecDestination.endpointTarget) && Objects.equals( this.endpointUrlKey, observabilityPipelineSplunkHecDestination.endpointUrlKey) && Objects.equals(this.id, observabilityPipelineSplunkHecDestination.id) @@ -468,6 +505,7 @@ public int hashCode() { autoExtractTimestamp, buffer, encoding, + endpointTarget, endpointUrlKey, id, index, @@ -489,6 +527,7 @@ public String toString() { .append("\n"); sb.append(" buffer: ").append(toIndentedString(buffer)).append("\n"); sb.append(" encoding: ").append(toIndentedString(encoding)).append("\n"); + sb.append(" endpointTarget: ").append(toIndentedString(endpointTarget)).append("\n"); sb.append(" endpointUrlKey: ").append(toIndentedString(endpointUrlKey)).append("\n"); sb.append(" id: ").append(toIndentedString(id)).append("\n"); sb.append(" index: ").append(toIndentedString(index)).append("\n"); diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestinationEndpointTarget.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestinationEndpointTarget.java new file mode 100644 index 00000000000..f79e9dc25bd --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkHecDestinationEndpointTarget.java @@ -0,0 +1,69 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +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 Splunk HEC endpoint to send events to. Use event to send structured events to + * the /event endpoint, or raw to send the raw message to the /raw + * endpoint. + */ +@JsonSerialize( + using = + ObservabilityPipelineSplunkHecDestinationEndpointTarget + .ObservabilityPipelineSplunkHecDestinationEndpointTargetSerializer.class) +public class ObservabilityPipelineSplunkHecDestinationEndpointTarget extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("event", "raw")); + + public static final ObservabilityPipelineSplunkHecDestinationEndpointTarget EVENT = + new ObservabilityPipelineSplunkHecDestinationEndpointTarget("event"); + public static final ObservabilityPipelineSplunkHecDestinationEndpointTarget RAW = + new ObservabilityPipelineSplunkHecDestinationEndpointTarget("raw"); + + ObservabilityPipelineSplunkHecDestinationEndpointTarget(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineSplunkHecDestinationEndpointTargetSerializer + extends StdSerializer { + public ObservabilityPipelineSplunkHecDestinationEndpointTargetSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineSplunkHecDestinationEndpointTargetSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineSplunkHecDestinationEndpointTarget value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineSplunkHecDestinationEndpointTarget fromValue(String value) { + return new ObservabilityPipelineSplunkHecDestinationEndpointTarget(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 8aa6ef36159..a2d4f82677a 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 @@ -239,6 +239,14 @@ Feature: Observability Pipelines Then the response status is 200 OK And the response "errors" has length 0 + @team:DataDog/observability-pipelines + Scenario: Validate an observability pipeline with Splunk HEC destination endpoint_target returns "OK" response + Given new "ValidatePipeline" request + And body with value {"data": {"attributes": {"config": {"destinations": [{"id": "splunk-hec-destination", "inputs": ["my-processor-group"], "type": "splunk_hec", "token_key": "SPLUNK_HEC_TOKEN", "endpoint_target": "raw"}], "processor_groups": [{"enabled": true, "id": "my-processor-group", "include": "service:my-service", "inputs": ["datadog-agent-source"], "processors": [{"enabled": true, "id": "filter-processor", "include": "status:error", "type": "filter"}]}], "sources": [{"id": "datadog-agent-source", "type": "datadog_agent"}]}, "name": "Pipeline with Splunk HEC endpoint_target"}, "type": "pipelines"}} + When the request is sent + Then the response status is 200 OK + And the response "errors" has length 0 + @team:DataDog/observability-pipelines Scenario: Validate an observability pipeline with Splunk HEC destination token_strategy 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 fb7db31e3f5..709bfa675c0 100644 --- a/src/test/resources/generated-test/test-runner-data/manifest.json +++ b/src/test/resources/generated-test/test-runner-data/manifest.json @@ -7952,6 +7952,13 @@ "scenario": "Validate an observability pipeline with OCSF mapper library mapping 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-splunk-hec-destination-endpoint-target-returns-ok-response.json", + "scenario": "Validate an observability pipeline with Splunk HEC destination endpoint_target 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-splunk-hec-destination-endpoint-target-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-splunk-hec-destination-endpoint-target-returns-ok-response.json new file mode 100644 index 00000000000..e2faac1ac18 --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-splunk-hec-destination-endpoint-target-returns-ok-response.json @@ -0,0 +1,70 @@ +{ + "api": "ObservabilityPipelines", + "expected_status": 200, + "feature": "Observability Pipelines", + "id": "v2/Observability Pipelines/Validate an observability pipeline with Splunk HEC destination endpoint_target returns \"OK\" response", + "operation_id": "ValidatePipeline", + "request": { + "body": { + "schema": { + "format": null, + "ref": "ObservabilityPipelineSpec", + "type": "object" + }, + "source": "inline", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "endpoint_target": "raw", + "id": "splunk-hec-destination", + "inputs": [ + "my-processor-group" + ], + "token_key": "SPLUNK_HEC_TOKEN", + "type": "splunk_hec" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "enabled": true, + "id": "filter-processor", + "include": "status:error", + "type": "filter" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Splunk HEC endpoint_target" + }, + "type": "pipelines" + } + } + }, + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v2/obs-pipelines/pipelines/validate" + }, + "scenario": "Validate an observability pipeline with Splunk HEC destination endpoint_target 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 5f241d965c9..7dd69e456cd 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 @@ -2165,6 +2165,81 @@ "scenario": "Validate an observability pipeline with OCSF mapper library mapping returns \"OK\" response", "version": "v2" }, + { + "feature": "Observability Pipelines", + "frozen_at": "2026-08-03T12:48:21.947Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": { + "data": { + "attributes": { + "config": { + "destinations": [ + { + "endpoint_target": "raw", + "id": "splunk-hec-destination", + "inputs": [ + "my-processor-group" + ], + "token_key": "SPLUNK_HEC_TOKEN", + "type": "splunk_hec" + } + ], + "processor_groups": [ + { + "enabled": true, + "id": "my-processor-group", + "include": "service:my-service", + "inputs": [ + "datadog-agent-source" + ], + "processors": [ + { + "enabled": true, + "id": "filter-processor", + "include": "status:error", + "type": "filter" + } + ] + } + ], + "sources": [ + { + "id": "datadog-agent-source", + "type": "datadog_agent" + } + ] + }, + "name": "Pipeline with Splunk HEC endpoint_target" + }, + "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 Splunk HEC destination endpoint_target returns \"OK\" response", + "version": "v2" + }, { "feature": "Observability Pipelines", "frozen_at": "2026-04-08T15:11:59.762Z",