diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c78659f543e..80375b8598d 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -77249,6 +77249,13 @@ components: 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: splunk-tcp-source type: string + max_connection_duration_secs: + description: Maximum duration, in seconds, that a connection can remain open before it is closed. When unset, connections can remain open indefinitely. + example: 3600 + format: int64 + maximum: 9007199254740991 + minimum: 1 + type: integer tls: $ref: "#/components/schemas/ObservabilityPipelineMtlsServerTls" type: diff --git a/examples/v2/observability-pipelines/ValidatePipeline_3116312807.java b/examples/v2/observability-pipelines/ValidatePipeline_3116312807.java new file mode 100644 index 00000000000..17a2fb9747a --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_3116312807.java @@ -0,0 +1,89 @@ +// Validate an observability pipeline with Splunk TCP source max_connection_duration_secs 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.ObservabilityPipelineDatadogLogsDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineDatadogLogsDestinationType; +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.ObservabilityPipelineSplunkTcpSource; +import com.datadog.api.client.v2.model.ObservabilityPipelineSplunkTcpSourceType; +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 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("splunk-tcp-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 ObservabilityPipelineSplunkTcpSource() + .id("splunk-tcp-source") + .type( + ObservabilityPipelineSplunkTcpSourceType + .SPLUNK_TCP) + .maxConnectionDurationSecs(3600L))))) + .name("Pipeline with Splunk TCP max connection duration")) + .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/ObservabilityPipelineSplunkTcpSource.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkTcpSource.java index ac23928a17d..1d91422b3dd 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkTcpSource.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineSplunkTcpSource.java @@ -26,6 +26,7 @@ @JsonPropertyOrder({ ObservabilityPipelineSplunkTcpSource.JSON_PROPERTY_ADDRESS_KEY, ObservabilityPipelineSplunkTcpSource.JSON_PROPERTY_ID, + ObservabilityPipelineSplunkTcpSource.JSON_PROPERTY_MAX_CONNECTION_DURATION_SECS, ObservabilityPipelineSplunkTcpSource.JSON_PROPERTY_TLS, ObservabilityPipelineSplunkTcpSource.JSON_PROPERTY_TYPE }) @@ -39,6 +40,10 @@ public class ObservabilityPipelineSplunkTcpSource { public static final String JSON_PROPERTY_ID = "id"; private String id; + public static final String JSON_PROPERTY_MAX_CONNECTION_DURATION_SECS = + "max_connection_duration_secs"; + private Long maxConnectionDurationSecs; + public static final String JSON_PROPERTY_TLS = "tls"; private ObservabilityPipelineMtlsServerTls tls; @@ -101,6 +106,29 @@ public void setId(String id) { this.id = id; } + public ObservabilityPipelineSplunkTcpSource maxConnectionDurationSecs( + Long maxConnectionDurationSecs) { + this.maxConnectionDurationSecs = maxConnectionDurationSecs; + return this; + } + + /** + * Maximum duration, in seconds, that a connection can remain open before it is closed. When + * unset, connections can remain open indefinitely. minimum: 1 maximum: 9007199254740991 + * + * @return maxConnectionDurationSecs + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MAX_CONNECTION_DURATION_SECS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getMaxConnectionDurationSecs() { + return maxConnectionDurationSecs; + } + + public void setMaxConnectionDurationSecs(Long maxConnectionDurationSecs) { + this.maxConnectionDurationSecs = maxConnectionDurationSecs; + } + public ObservabilityPipelineSplunkTcpSource tls(ObservabilityPipelineMtlsServerTls tls) { this.tls = tls; this.unparsed |= tls.unparsed; @@ -210,6 +238,9 @@ public boolean equals(Object o) { (ObservabilityPipelineSplunkTcpSource) o; return Objects.equals(this.addressKey, observabilityPipelineSplunkTcpSource.addressKey) && Objects.equals(this.id, observabilityPipelineSplunkTcpSource.id) + && Objects.equals( + this.maxConnectionDurationSecs, + observabilityPipelineSplunkTcpSource.maxConnectionDurationSecs) && Objects.equals(this.tls, observabilityPipelineSplunkTcpSource.tls) && Objects.equals(this.type, observabilityPipelineSplunkTcpSource.type) && Objects.equals( @@ -218,7 +249,7 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(addressKey, id, tls, type, additionalProperties); + return Objects.hash(addressKey, id, maxConnectionDurationSecs, tls, type, additionalProperties); } @Override @@ -227,6 +258,9 @@ public String toString() { sb.append("class ObservabilityPipelineSplunkTcpSource {\n"); sb.append(" addressKey: ").append(toIndentedString(addressKey)).append("\n"); sb.append(" id: ").append(toIndentedString(id)).append("\n"); + sb.append(" maxConnectionDurationSecs: ") + .append(toIndentedString(maxConnectionDurationSecs)) + .append("\n"); sb.append(" tls: ").append(toIndentedString(tls)).append("\n"); sb.append(" type: ").append(toIndentedString(type)).append("\n"); sb.append(" additionalProperties: ") 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 a2d4f82677a..78729ae2e8b 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 @@ -271,6 +271,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 TCP source max_connection_duration_secs 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": ["splunk-tcp-source"], "processors": [{"enabled": true, "id": "filter-processor", "include": "status:error", "type": "filter"}]}], "sources": [{"id": "splunk-tcp-source", "type": "splunk_tcp", "max_connection_duration_secs": 3600}]}, "name": "Pipeline with Splunk TCP max connection duration"}, "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 amazon S3 source compression 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 084ef46edee..2ca1c742b53 100644 --- a/src/test/resources/generated-test/test-runner-data/manifest.json +++ b/src/test/resources/generated-test/test-runner-data/manifest.json @@ -7980,6 +7980,13 @@ "scenario": "Validate an observability pipeline with Splunk HEC source valid_tokens 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-tcp-source-max-connection-duration-secs-returns-ok-response.json", + "scenario": "Validate an observability pipeline with Splunk TCP source max_connection_duration_secs 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-tcp-source-max-connection-duration-secs-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-splunk-tcp-source-max-connection-duration-secs-returns-ok-response.json new file mode 100644 index 00000000000..e7bd480865e --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v2/observability-pipelines/validate-an-observability-pipeline-with-splunk-tcp-source-max-connection-duration-secs-returns-ok-response.json @@ -0,0 +1,69 @@ +{ + "api": "ObservabilityPipelines", + "expected_status": 200, + "feature": "Observability Pipelines", + "id": "v2/Observability Pipelines/Validate an observability pipeline with Splunk TCP source max_connection_duration_secs 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": [ + "splunk-tcp-source" + ], + "processors": [ + { + "enabled": true, + "id": "filter-processor", + "include": "status:error", + "type": "filter" + } + ] + } + ], + "sources": [ + { + "id": "splunk-tcp-source", + "max_connection_duration_secs": 3600, + "type": "splunk_tcp" + } + ] + }, + "name": "Pipeline with Splunk TCP max connection duration" + }, + "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 TCP source max_connection_duration_secs 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 7dd69e456cd..428d57f5b9d 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 @@ -2476,6 +2476,80 @@ "scenario": "Validate an observability pipeline with Splunk HEC source valid_tokens returns \"OK\" response", "version": "v2" }, + { + "feature": "Observability Pipelines", + "frozen_at": "2026-09-02T13:38:34.105Z", + "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": [ + "splunk-tcp-source" + ], + "processors": [ + { + "enabled": true, + "id": "filter-processor", + "include": "status:error", + "type": "filter" + } + ] + } + ], + "sources": [ + { + "id": "splunk-tcp-source", + "max_connection_duration_secs": 3600, + "type": "splunk_tcp" + } + ] + }, + "name": "Pipeline with Splunk TCP max connection duration" + }, + "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 TCP source max_connection_duration_secs returns \"OK\" response", + "version": "v2" + }, { "feature": "Observability Pipelines", "frozen_at": "2026-04-08T12:44:25.060Z",