diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 954f75f844f..b1469c0ac20 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -63744,6 +63744,199 @@ components: x-enum-varnames: - BLOCK - DROP_NEWEST + ObservabilityPipelineClickhouseDestination: + description: |- + The `clickhouse` destination sends log events to a ClickHouse database table over HTTP. + + **Supported pipeline types:** logs. + properties: + auth: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationAuth" + batch: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationBatch" + batch_encoding: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationBatchEncoding" + compression: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationCompression" + database: + description: Optional ClickHouse database name. If omitted, the user's default database on the ClickHouse server is used. + example: my_database + type: string + date_time_best_effort: + description: When `true`, enables flexible DateTime parsing on the ClickHouse server side. + example: false + type: boolean + endpoint_url_key: + description: |- + Name of the environment variable or secret that contains the ClickHouse HTTP endpoint URL. + Defaults to `DESTINATION_CLICKHOUSE_ENDPOINT_URL` (prefixed with `DD_OP_` at runtime). + example: CLICKHOUSE_ENDPOINT_URL + type: string + format: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationFormat" + id: + description: The unique identifier for this component. + example: clickhouse-destination + type: string + inputs: + description: A list of component IDs whose output is used as the `input` for this component. + example: ["filter-processor"] + items: + description: The ID of a component whose output is used as input for this destination. + type: string + type: array + skip_unknown_fields: + description: |- + When `true`, fields not present in the target table schema are dropped instead of causing insert errors. + When unset, the ClickHouse server's own `input_format_skip_unknown_fields` setting applies. + example: true + nullable: true + type: boolean + table: + description: Target ClickHouse table name. Events are inserted into this table. + example: application_logs + type: string + tls: + $ref: "#/components/schemas/ObservabilityPipelineTls" + type: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationType" + required: + - id + - type + - inputs + - table + type: object + x-pipeline-types: [logs] + ObservabilityPipelineClickhouseDestinationAuth: + description: |- + HTTP Basic Authentication credentials for the ClickHouse destination. + When `strategy` is `basic`, provide `username_key` and `password_key` that reference environment variables or secrets containing the credentials. + properties: + password_key: + description: Name of the environment variable or secret that contains the ClickHouse password. + example: CLICKHOUSE_PASSWORD + type: string + strategy: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationAuthStrategy" + username_key: + description: Name of the environment variable or secret that contains the ClickHouse username. + example: CLICKHOUSE_USERNAME + type: string + required: + - strategy + type: object + ObservabilityPipelineClickhouseDestinationAuthStrategy: + description: The authentication strategy for ClickHouse HTTP requests. Only `basic` is supported. + enum: + - basic + example: basic + type: string + x-enum-varnames: + - BASIC + ObservabilityPipelineClickhouseDestinationBatch: + description: Batching configuration for ClickHouse inserts. + properties: + max_events: + description: Maximum number of events per batch before it is flushed. + example: 1000 + format: int64 + minimum: 1 + type: integer + timeout_secs: + description: Maximum number of seconds to wait before flushing a partial batch. + example: 1 + format: int64 + maximum: 65535 + minimum: 1 + type: integer + type: object + ObservabilityPipelineClickhouseDestinationBatchEncoding: + description: |- + Batch encoding configuration for the ClickHouse destination. + Required when `format` is `arrow_stream`. The `codec` field must be set to `arrow_stream`. + properties: + allow_nullable_fields: + description: |- + When `true`, null values are allowed for non-nullable fields in the ClickHouse schema. + When `false` (default), missing values for non-nullable columns cause encoding errors. + example: false + type: boolean + codec: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationBatchEncodingCodec" + required: + - codec + type: object + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec: + description: The codec used for batch encoding. Only `arrow_stream` is supported. + enum: + - arrow_stream + example: arrow_stream + type: string + x-enum-varnames: + - ARROW_STREAM + ObservabilityPipelineClickhouseDestinationCompression: + description: |- + Compression setting for outbound HTTP requests to ClickHouse. + Can be specified as a shorthand string (`"gzip"` or `"none"`) or as an object + with an `algorithm` field and an optional `level` (gzip only, 1–9). + oneOf: + - $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationCompressionAlgorithm" + - $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationCompressionObject" + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm: + description: The compression algorithm applied to outbound HTTP requests. + enum: + - gzip + - none + example: gzip + type: string + x-enum-varnames: + - GZIP + - NONE + ObservabilityPipelineClickhouseDestinationCompressionObject: + description: |- + Structured compression configuration for the ClickHouse destination. + Use `algorithm` to specify the compression type and `level` (optional, gzip only) to control compression strength. + properties: + algorithm: + $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestinationCompressionAlgorithm" + level: + description: Compression level (1–9). Only applicable when `algorithm` is `gzip`. + example: 6 + format: int64 + maximum: 9 + minimum: 1 + type: integer + required: + - algorithm + type: object + ObservabilityPipelineClickhouseDestinationFormat: + description: |- + Insert format for events sent to ClickHouse. + - `json_each_row`: Maps event fields to columns by name (ClickHouse `JSONEachRow`). + - `json_as_object`: Inserts each event into a single `Object('json')` / `JSON` column (ClickHouse `JSONAsObject`). + - `json_as_string`: Inserts each event into a single `String`-typed column as raw JSON (ClickHouse `JSONAsString`). + - `arrow_stream`: Batches events using Apache Arrow IPC streaming format. Requires `batch_encoding`. + enum: + - json_each_row + - json_as_object + - json_as_string + - arrow_stream + example: json_each_row + type: string + x-enum-varnames: + - JSON_EACH_ROW + - JSON_AS_OBJECT + - JSON_AS_STRING + - ARROW_STREAM + ObservabilityPipelineClickhouseDestinationType: + default: clickhouse + description: The destination type. The value must be `clickhouse`. + enum: + - clickhouse + example: clickhouse + type: string + x-enum-varnames: + - CLICKHOUSE ObservabilityPipelineCloudPremDestination: description: |- The `cloud_prem` destination sends logs to Datadog CloudPrem. @@ -63843,6 +64036,7 @@ components: - $ref: "#/components/schemas/ObservabilityPipelineAmazonS3GenericDestination" - $ref: "#/components/schemas/ObservabilityPipelineAmazonSecurityLakeDestination" - $ref: "#/components/schemas/AzureStorageDestination" + - $ref: "#/components/schemas/ObservabilityPipelineClickhouseDestination" - $ref: "#/components/schemas/ObservabilityPipelineCloudPremDestination" - $ref: "#/components/schemas/ObservabilityPipelineCrowdStrikeNextGenSiemDestination" - $ref: "#/components/schemas/ObservabilityPipelineDatadogLogsDestination" diff --git a/examples/v2/observability-pipelines/ValidatePipeline_1238441879.java b/examples/v2/observability-pipelines/ValidatePipeline_1238441879.java new file mode 100644 index 00000000000..f40bde76eac --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_1238441879.java @@ -0,0 +1,110 @@ +// Validate an observability pipeline with ClickHouse destination 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.ObservabilityPipelineClickhouseDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationAuth; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationAuthStrategy; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationBatch; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationCompression; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationCompressionAlgorithm; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationType; +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.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 ObservabilityPipelineClickhouseDestination() + .id("clickhouse-destination") + .inputs( + Collections.singletonList( + "my-processor-group")) + .type( + ObservabilityPipelineClickhouseDestinationType + .CLICKHOUSE) + .table("application_logs") + .database("my_database") + .compression( + new ObservabilityPipelineClickhouseDestinationCompression( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + .GZIP)) + .auth( + new ObservabilityPipelineClickhouseDestinationAuth() + .strategy( + ObservabilityPipelineClickhouseDestinationAuthStrategy + .BASIC) + .usernameKey("CLICKHOUSE_USERNAME") + .passwordKey("CLICKHOUSE_PASSWORD")) + .batch( + new ObservabilityPipelineClickhouseDestinationBatch() + .maxEvents(1000L) + .timeoutSecs(1L))))) + .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 ClickHouse Destination")) + .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_620504950.java b/examples/v2/observability-pipelines/ValidatePipeline_620504950.java new file mode 100644 index 00000000000..dfcb3db6e4d --- /dev/null +++ b/examples/v2/observability-pipelines/ValidatePipeline_620504950.java @@ -0,0 +1,123 @@ +// Validate an observability pipeline with ClickHouse destination arrow_stream format 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.ObservabilityPipelineClickhouseDestination; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationAuth; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationAuthStrategy; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationBatch; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationBatchEncoding; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationBatchEncodingCodec; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationCompression; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationCompressionAlgorithm; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationFormat; +import com.datadog.api.client.v2.model.ObservabilityPipelineClickhouseDestinationType; +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.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 ObservabilityPipelineClickhouseDestination() + .id("clickhouse-destination") + .inputs( + Collections.singletonList( + "my-processor-group")) + .type( + ObservabilityPipelineClickhouseDestinationType + .CLICKHOUSE) + .table("application_logs") + .database("my_database") + .format( + ObservabilityPipelineClickhouseDestinationFormat + .ARROW_STREAM) + .batchEncoding( + new ObservabilityPipelineClickhouseDestinationBatchEncoding() + .codec( + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec + .ARROW_STREAM) + .allowNullableFields(false)) + .compression( + new ObservabilityPipelineClickhouseDestinationCompression( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + .GZIP)) + .auth( + new ObservabilityPipelineClickhouseDestinationAuth() + .strategy( + ObservabilityPipelineClickhouseDestinationAuthStrategy + .BASIC) + .usernameKey("CLICKHOUSE_USERNAME") + .passwordKey("CLICKHOUSE_PASSWORD")) + .batch( + new ObservabilityPipelineClickhouseDestinationBatch() + .maxEvents(1000L) + .timeoutSecs(1L))))) + .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 ClickHouse Destination Arrow Stream")) + .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/ObservabilityPipelineClickhouseDestination.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestination.java new file mode 100644 index 00000000000..8b5be2129ff --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestination.java @@ -0,0 +1,585 @@ +/* + * 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; +import org.openapitools.jackson.nullable.JsonNullable; + +/** + * The clickhouse destination sends log events to a ClickHouse database table over + * HTTP. + * + *

Supported pipeline types: logs. + */ +@JsonPropertyOrder({ + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_AUTH, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_BATCH, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_BATCH_ENCODING, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_COMPRESSION, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_DATABASE, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_DATE_TIME_BEST_EFFORT, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_ENDPOINT_URL_KEY, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_FORMAT, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_ID, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_INPUTS, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_SKIP_UNKNOWN_FIELDS, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_TABLE, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_TLS, + ObservabilityPipelineClickhouseDestination.JSON_PROPERTY_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineClickhouseDestination { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_AUTH = "auth"; + private ObservabilityPipelineClickhouseDestinationAuth auth; + + public static final String JSON_PROPERTY_BATCH = "batch"; + private ObservabilityPipelineClickhouseDestinationBatch batch; + + public static final String JSON_PROPERTY_BATCH_ENCODING = "batch_encoding"; + private ObservabilityPipelineClickhouseDestinationBatchEncoding batchEncoding; + + public static final String JSON_PROPERTY_COMPRESSION = "compression"; + private ObservabilityPipelineClickhouseDestinationCompression compression; + + public static final String JSON_PROPERTY_DATABASE = "database"; + private String database; + + public static final String JSON_PROPERTY_DATE_TIME_BEST_EFFORT = "date_time_best_effort"; + private Boolean dateTimeBestEffort; + + public static final String JSON_PROPERTY_ENDPOINT_URL_KEY = "endpoint_url_key"; + private String endpointUrlKey; + + public static final String JSON_PROPERTY_FORMAT = "format"; + private ObservabilityPipelineClickhouseDestinationFormat format; + + public static final String JSON_PROPERTY_ID = "id"; + private String id; + + public static final String JSON_PROPERTY_INPUTS = "inputs"; + private List inputs = new ArrayList<>(); + + public static final String JSON_PROPERTY_SKIP_UNKNOWN_FIELDS = "skip_unknown_fields"; + private JsonNullable skipUnknownFields = JsonNullable.undefined(); + + public static final String JSON_PROPERTY_TABLE = "table"; + private String table; + + public static final String JSON_PROPERTY_TLS = "tls"; + private ObservabilityPipelineTls tls; + + public static final String JSON_PROPERTY_TYPE = "type"; + private ObservabilityPipelineClickhouseDestinationType type = + ObservabilityPipelineClickhouseDestinationType.CLICKHOUSE; + + public ObservabilityPipelineClickhouseDestination() {} + + @JsonCreator + public ObservabilityPipelineClickhouseDestination( + @JsonProperty(required = true, value = JSON_PROPERTY_ID) String id, + @JsonProperty(required = true, value = JSON_PROPERTY_INPUTS) List inputs, + @JsonProperty(required = true, value = JSON_PROPERTY_TABLE) String table, + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + ObservabilityPipelineClickhouseDestinationType type) { + this.id = id; + this.inputs = inputs; + this.table = table; + this.type = type; + this.unparsed |= !type.isValid(); + } + + public ObservabilityPipelineClickhouseDestination auth( + ObservabilityPipelineClickhouseDestinationAuth auth) { + this.auth = auth; + this.unparsed |= auth.unparsed; + return this; + } + + /** + * HTTP Basic Authentication credentials for the ClickHouse destination. When strategy + * is basic, provide username_key and password_key + * that reference environment variables or secrets containing the credentials. + * + * @return auth + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_AUTH) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineClickhouseDestinationAuth getAuth() { + return auth; + } + + public void setAuth(ObservabilityPipelineClickhouseDestinationAuth auth) { + this.auth = auth; + } + + public ObservabilityPipelineClickhouseDestination batch( + ObservabilityPipelineClickhouseDestinationBatch batch) { + this.batch = batch; + this.unparsed |= batch.unparsed; + return this; + } + + /** + * Batching configuration for ClickHouse inserts. + * + * @return batch + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_BATCH) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineClickhouseDestinationBatch getBatch() { + return batch; + } + + public void setBatch(ObservabilityPipelineClickhouseDestinationBatch batch) { + this.batch = batch; + } + + public ObservabilityPipelineClickhouseDestination batchEncoding( + ObservabilityPipelineClickhouseDestinationBatchEncoding batchEncoding) { + this.batchEncoding = batchEncoding; + this.unparsed |= batchEncoding.unparsed; + return this; + } + + /** + * Batch encoding configuration for the ClickHouse destination. Required when format + * is arrow_stream. The codec field must be set to arrow_stream + * . + * + * @return batchEncoding + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_BATCH_ENCODING) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineClickhouseDestinationBatchEncoding getBatchEncoding() { + return batchEncoding; + } + + public void setBatchEncoding( + ObservabilityPipelineClickhouseDestinationBatchEncoding batchEncoding) { + this.batchEncoding = batchEncoding; + } + + public ObservabilityPipelineClickhouseDestination compression( + ObservabilityPipelineClickhouseDestinationCompression compression) { + this.compression = compression; + this.unparsed |= compression.unparsed; + return this; + } + + /** + * Compression setting for outbound HTTP requests to ClickHouse. Can be specified as a shorthand + * string ("gzip" or "none") or as an object with an algorithm + * field and an optional level (gzip only, 1–9). + * + * @return compression + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_COMPRESSION) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineClickhouseDestinationCompression getCompression() { + return compression; + } + + public void setCompression(ObservabilityPipelineClickhouseDestinationCompression compression) { + this.compression = compression; + } + + public ObservabilityPipelineClickhouseDestination database(String database) { + this.database = database; + return this; + } + + /** + * Optional ClickHouse database name. If omitted, the user's default database on the ClickHouse + * server is used. + * + * @return database + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_DATABASE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getDatabase() { + return database; + } + + public void setDatabase(String database) { + this.database = database; + } + + public ObservabilityPipelineClickhouseDestination dateTimeBestEffort(Boolean dateTimeBestEffort) { + this.dateTimeBestEffort = dateTimeBestEffort; + return this; + } + + /** + * When true, enables flexible DateTime parsing on the ClickHouse server side. + * + * @return dateTimeBestEffort + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_DATE_TIME_BEST_EFFORT) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Boolean getDateTimeBestEffort() { + return dateTimeBestEffort; + } + + public void setDateTimeBestEffort(Boolean dateTimeBestEffort) { + this.dateTimeBestEffort = dateTimeBestEffort; + } + + public ObservabilityPipelineClickhouseDestination endpointUrlKey(String endpointUrlKey) { + this.endpointUrlKey = endpointUrlKey; + return this; + } + + /** + * Name of the environment variable or secret that contains the ClickHouse HTTP endpoint URL. + * Defaults to DESTINATION_CLICKHOUSE_ENDPOINT_URL (prefixed with DD_OP_ + * at runtime). + * + * @return endpointUrlKey + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ENDPOINT_URL_KEY) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getEndpointUrlKey() { + return endpointUrlKey; + } + + public void setEndpointUrlKey(String endpointUrlKey) { + this.endpointUrlKey = endpointUrlKey; + } + + public ObservabilityPipelineClickhouseDestination format( + ObservabilityPipelineClickhouseDestinationFormat format) { + this.format = format; + this.unparsed |= !format.isValid(); + return this; + } + + /** + * Insert format for events sent to ClickHouse. - json_each_row: Maps event fields to + * columns by name (ClickHouse JSONEachRow). - json_as_object: Inserts + * each event into a single Object('json') / JSON column (ClickHouse + * JSONAsObject). - json_as_string: Inserts each event into a single + * String-typed column as raw JSON (ClickHouse JSONAsString). - + * arrow_stream: Batches events using Apache Arrow IPC streaming format. Requires + * batch_encoding. + * + * @return format + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_FORMAT) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineClickhouseDestinationFormat getFormat() { + return format; + } + + public void setFormat(ObservabilityPipelineClickhouseDestinationFormat format) { + if (!format.isValid()) { + this.unparsed = true; + } + this.format = format; + } + + public ObservabilityPipelineClickhouseDestination id(String id) { + this.id = id; + return this; + } + + /** + * The unique identifier for this component. + * + * @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 ObservabilityPipelineClickhouseDestination inputs(List inputs) { + this.inputs = inputs; + return this; + } + + public ObservabilityPipelineClickhouseDestination addInputsItem(String inputsItem) { + this.inputs.add(inputsItem); + return this; + } + + /** + * A list of component IDs whose output is used as the input for this component. + * + * @return inputs + */ + @JsonProperty(JSON_PROPERTY_INPUTS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getInputs() { + return inputs; + } + + public void setInputs(List inputs) { + this.inputs = inputs; + } + + public ObservabilityPipelineClickhouseDestination skipUnknownFields(Boolean skipUnknownFields) { + this.skipUnknownFields = JsonNullable.of(skipUnknownFields); + return this; + } + + /** + * When true, fields not present in the target table schema are dropped instead of + * causing insert errors. When unset, the ClickHouse server's own + * input_format_skip_unknown_fields setting applies. + * + * @return skipUnknownFields + */ + @jakarta.annotation.Nullable + @JsonIgnore + public Boolean getSkipUnknownFields() { + return skipUnknownFields.orElse(null); + } + + @JsonProperty(JSON_PROPERTY_SKIP_UNKNOWN_FIELDS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public JsonNullable getSkipUnknownFields_JsonNullable() { + return skipUnknownFields; + } + + @JsonProperty(JSON_PROPERTY_SKIP_UNKNOWN_FIELDS) + public void setSkipUnknownFields_JsonNullable(JsonNullable skipUnknownFields) { + this.skipUnknownFields = skipUnknownFields; + } + + public void setSkipUnknownFields(Boolean skipUnknownFields) { + this.skipUnknownFields = JsonNullable.of(skipUnknownFields); + } + + public ObservabilityPipelineClickhouseDestination table(String table) { + this.table = table; + return this; + } + + /** + * Target ClickHouse table name. Events are inserted into this table. + * + * @return table + */ + @JsonProperty(JSON_PROPERTY_TABLE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getTable() { + return table; + } + + public void setTable(String table) { + this.table = table; + } + + public ObservabilityPipelineClickhouseDestination tls(ObservabilityPipelineTls tls) { + this.tls = tls; + this.unparsed |= tls.unparsed; + return this; + } + + /** + * Configuration for enabling TLS encryption between the pipeline component and external services. + * + * @return tls + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_TLS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public ObservabilityPipelineTls getTls() { + return tls; + } + + public void setTls(ObservabilityPipelineTls tls) { + this.tls = tls; + } + + public ObservabilityPipelineClickhouseDestination type( + ObservabilityPipelineClickhouseDestinationType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * The destination type. The value must be clickhouse. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineClickhouseDestinationType getType() { + return type; + } + + public void setType(ObservabilityPipelineClickhouseDestinationType 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 ObservabilityPipelineClickhouseDestination + */ + @JsonAnySetter + public ObservabilityPipelineClickhouseDestination 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 ObservabilityPipelineClickhouseDestination object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineClickhouseDestination observabilityPipelineClickhouseDestination = + (ObservabilityPipelineClickhouseDestination) o; + return Objects.equals(this.auth, observabilityPipelineClickhouseDestination.auth) + && Objects.equals(this.batch, observabilityPipelineClickhouseDestination.batch) + && Objects.equals( + this.batchEncoding, observabilityPipelineClickhouseDestination.batchEncoding) + && Objects.equals(this.compression, observabilityPipelineClickhouseDestination.compression) + && Objects.equals(this.database, observabilityPipelineClickhouseDestination.database) + && Objects.equals( + this.dateTimeBestEffort, observabilityPipelineClickhouseDestination.dateTimeBestEffort) + && Objects.equals( + this.endpointUrlKey, observabilityPipelineClickhouseDestination.endpointUrlKey) + && Objects.equals(this.format, observabilityPipelineClickhouseDestination.format) + && Objects.equals(this.id, observabilityPipelineClickhouseDestination.id) + && Objects.equals(this.inputs, observabilityPipelineClickhouseDestination.inputs) + && Objects.equals( + this.skipUnknownFields, observabilityPipelineClickhouseDestination.skipUnknownFields) + && Objects.equals(this.table, observabilityPipelineClickhouseDestination.table) + && Objects.equals(this.tls, observabilityPipelineClickhouseDestination.tls) + && Objects.equals(this.type, observabilityPipelineClickhouseDestination.type) + && Objects.equals( + this.additionalProperties, + observabilityPipelineClickhouseDestination.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + auth, + batch, + batchEncoding, + compression, + database, + dateTimeBestEffort, + endpointUrlKey, + format, + id, + inputs, + skipUnknownFields, + table, + tls, + type, + additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineClickhouseDestination {\n"); + sb.append(" auth: ").append(toIndentedString(auth)).append("\n"); + sb.append(" batch: ").append(toIndentedString(batch)).append("\n"); + sb.append(" batchEncoding: ").append(toIndentedString(batchEncoding)).append("\n"); + sb.append(" compression: ").append(toIndentedString(compression)).append("\n"); + sb.append(" database: ").append(toIndentedString(database)).append("\n"); + sb.append(" dateTimeBestEffort: ").append(toIndentedString(dateTimeBestEffort)).append("\n"); + sb.append(" endpointUrlKey: ").append(toIndentedString(endpointUrlKey)).append("\n"); + sb.append(" format: ").append(toIndentedString(format)).append("\n"); + sb.append(" id: ").append(toIndentedString(id)).append("\n"); + sb.append(" inputs: ").append(toIndentedString(inputs)).append("\n"); + sb.append(" skipUnknownFields: ").append(toIndentedString(skipUnknownFields)).append("\n"); + sb.append(" table: ").append(toIndentedString(table)).append("\n"); + sb.append(" tls: ").append(toIndentedString(tls)).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/ObservabilityPipelineClickhouseDestinationAuth.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationAuth.java new file mode 100644 index 00000000000..83111bc13db --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationAuth.java @@ -0,0 +1,216 @@ +/* + * 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; + +/** + * HTTP Basic Authentication credentials for the ClickHouse destination. When strategy + * is basic, provide username_key and password_key that + * reference environment variables or secrets containing the credentials. + */ +@JsonPropertyOrder({ + ObservabilityPipelineClickhouseDestinationAuth.JSON_PROPERTY_PASSWORD_KEY, + ObservabilityPipelineClickhouseDestinationAuth.JSON_PROPERTY_STRATEGY, + ObservabilityPipelineClickhouseDestinationAuth.JSON_PROPERTY_USERNAME_KEY +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineClickhouseDestinationAuth { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_PASSWORD_KEY = "password_key"; + private String passwordKey; + + public static final String JSON_PROPERTY_STRATEGY = "strategy"; + private ObservabilityPipelineClickhouseDestinationAuthStrategy strategy; + + public static final String JSON_PROPERTY_USERNAME_KEY = "username_key"; + private String usernameKey; + + public ObservabilityPipelineClickhouseDestinationAuth() {} + + @JsonCreator + public ObservabilityPipelineClickhouseDestinationAuth( + @JsonProperty(required = true, value = JSON_PROPERTY_STRATEGY) + ObservabilityPipelineClickhouseDestinationAuthStrategy strategy) { + this.strategy = strategy; + this.unparsed |= !strategy.isValid(); + } + + public ObservabilityPipelineClickhouseDestinationAuth passwordKey(String passwordKey) { + this.passwordKey = passwordKey; + return this; + } + + /** + * Name of the environment variable or secret that contains the ClickHouse password. + * + * @return passwordKey + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_PASSWORD_KEY) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getPasswordKey() { + return passwordKey; + } + + public void setPasswordKey(String passwordKey) { + this.passwordKey = passwordKey; + } + + public ObservabilityPipelineClickhouseDestinationAuth strategy( + ObservabilityPipelineClickhouseDestinationAuthStrategy strategy) { + this.strategy = strategy; + this.unparsed |= !strategy.isValid(); + return this; + } + + /** + * The authentication strategy for ClickHouse HTTP requests. Only basic is supported. + * + * @return strategy + */ + @JsonProperty(JSON_PROPERTY_STRATEGY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineClickhouseDestinationAuthStrategy getStrategy() { + return strategy; + } + + public void setStrategy(ObservabilityPipelineClickhouseDestinationAuthStrategy strategy) { + if (!strategy.isValid()) { + this.unparsed = true; + } + this.strategy = strategy; + } + + public ObservabilityPipelineClickhouseDestinationAuth usernameKey(String usernameKey) { + this.usernameKey = usernameKey; + return this; + } + + /** + * Name of the environment variable or secret that contains the ClickHouse username. + * + * @return usernameKey + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_USERNAME_KEY) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getUsernameKey() { + return usernameKey; + } + + public void setUsernameKey(String usernameKey) { + this.usernameKey = usernameKey; + } + + /** + * 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 ObservabilityPipelineClickhouseDestinationAuth + */ + @JsonAnySetter + public ObservabilityPipelineClickhouseDestinationAuth 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 ObservabilityPipelineClickhouseDestinationAuth object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineClickhouseDestinationAuth observabilityPipelineClickhouseDestinationAuth = + (ObservabilityPipelineClickhouseDestinationAuth) o; + return Objects.equals( + this.passwordKey, observabilityPipelineClickhouseDestinationAuth.passwordKey) + && Objects.equals(this.strategy, observabilityPipelineClickhouseDestinationAuth.strategy) + && Objects.equals( + this.usernameKey, observabilityPipelineClickhouseDestinationAuth.usernameKey) + && Objects.equals( + this.additionalProperties, + observabilityPipelineClickhouseDestinationAuth.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(passwordKey, strategy, usernameKey, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineClickhouseDestinationAuth {\n"); + sb.append(" passwordKey: ").append(toIndentedString(passwordKey)).append("\n"); + sb.append(" strategy: ").append(toIndentedString(strategy)).append("\n"); + sb.append(" usernameKey: ").append(toIndentedString(usernameKey)).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/ObservabilityPipelineClickhouseDestinationAuthStrategy.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationAuthStrategy.java new file mode 100644 index 00000000000..5b527d0b13d --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationAuthStrategy.java @@ -0,0 +1,64 @@ +/* + * 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 authentication strategy for ClickHouse HTTP requests. Only basic is supported. + */ +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationAuthStrategy + .ObservabilityPipelineClickhouseDestinationAuthStrategySerializer.class) +public class ObservabilityPipelineClickhouseDestinationAuthStrategy extends ModelEnum { + + private static final Set allowedValues = new HashSet(Arrays.asList("basic")); + + public static final ObservabilityPipelineClickhouseDestinationAuthStrategy BASIC = + new ObservabilityPipelineClickhouseDestinationAuthStrategy("basic"); + + ObservabilityPipelineClickhouseDestinationAuthStrategy(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineClickhouseDestinationAuthStrategySerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationAuthStrategySerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationAuthStrategySerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationAuthStrategy value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineClickhouseDestinationAuthStrategy fromValue(String value) { + return new ObservabilityPipelineClickhouseDestinationAuthStrategy(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatch.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatch.java new file mode 100644 index 00000000000..c662a2d21da --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatch.java @@ -0,0 +1,170 @@ +/* + * 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.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; + +/** Batching configuration for ClickHouse inserts. */ +@JsonPropertyOrder({ + ObservabilityPipelineClickhouseDestinationBatch.JSON_PROPERTY_MAX_EVENTS, + ObservabilityPipelineClickhouseDestinationBatch.JSON_PROPERTY_TIMEOUT_SECS +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineClickhouseDestinationBatch { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_MAX_EVENTS = "max_events"; + private Long maxEvents; + + public static final String JSON_PROPERTY_TIMEOUT_SECS = "timeout_secs"; + private Long timeoutSecs; + + public ObservabilityPipelineClickhouseDestinationBatch maxEvents(Long maxEvents) { + this.maxEvents = maxEvents; + return this; + } + + /** + * Maximum number of events per batch before it is flushed. minimum: 1 + * + * @return maxEvents + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MAX_EVENTS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getMaxEvents() { + return maxEvents; + } + + public void setMaxEvents(Long maxEvents) { + this.maxEvents = maxEvents; + } + + public ObservabilityPipelineClickhouseDestinationBatch timeoutSecs(Long timeoutSecs) { + this.timeoutSecs = timeoutSecs; + return this; + } + + /** + * Maximum number of seconds to wait before flushing a partial batch. minimum: 1 maximum: 65535 + * + * @return timeoutSecs + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_TIMEOUT_SECS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getTimeoutSecs() { + return timeoutSecs; + } + + public void setTimeoutSecs(Long timeoutSecs) { + this.timeoutSecs = timeoutSecs; + } + + /** + * 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 ObservabilityPipelineClickhouseDestinationBatch + */ + @JsonAnySetter + public ObservabilityPipelineClickhouseDestinationBatch 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 ObservabilityPipelineClickhouseDestinationBatch object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineClickhouseDestinationBatch + observabilityPipelineClickhouseDestinationBatch = + (ObservabilityPipelineClickhouseDestinationBatch) o; + return Objects.equals(this.maxEvents, observabilityPipelineClickhouseDestinationBatch.maxEvents) + && Objects.equals( + this.timeoutSecs, observabilityPipelineClickhouseDestinationBatch.timeoutSecs) + && Objects.equals( + this.additionalProperties, + observabilityPipelineClickhouseDestinationBatch.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(maxEvents, timeoutSecs, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineClickhouseDestinationBatch {\n"); + sb.append(" maxEvents: ").append(toIndentedString(maxEvents)).append("\n"); + sb.append(" timeoutSecs: ").append(toIndentedString(timeoutSecs)).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/ObservabilityPipelineClickhouseDestinationBatchEncoding.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatchEncoding.java new file mode 100644 index 00000000000..27fe5f207d2 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatchEncoding.java @@ -0,0 +1,197 @@ +/* + * 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; + +/** + * Batch encoding configuration for the ClickHouse destination. Required when format is + * arrow_stream. The codec field must be set to arrow_stream. + */ +@JsonPropertyOrder({ + ObservabilityPipelineClickhouseDestinationBatchEncoding.JSON_PROPERTY_ALLOW_NULLABLE_FIELDS, + ObservabilityPipelineClickhouseDestinationBatchEncoding.JSON_PROPERTY_CODEC +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineClickhouseDestinationBatchEncoding { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ALLOW_NULLABLE_FIELDS = "allow_nullable_fields"; + private Boolean allowNullableFields; + + public static final String JSON_PROPERTY_CODEC = "codec"; + private ObservabilityPipelineClickhouseDestinationBatchEncodingCodec codec; + + public ObservabilityPipelineClickhouseDestinationBatchEncoding() {} + + @JsonCreator + public ObservabilityPipelineClickhouseDestinationBatchEncoding( + @JsonProperty(required = true, value = JSON_PROPERTY_CODEC) + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec codec) { + this.codec = codec; + this.unparsed |= !codec.isValid(); + } + + public ObservabilityPipelineClickhouseDestinationBatchEncoding allowNullableFields( + Boolean allowNullableFields) { + this.allowNullableFields = allowNullableFields; + return this; + } + + /** + * When true, null values are allowed for non-nullable fields in the ClickHouse + * schema. When false (default), missing values for non-nullable columns cause + * encoding errors. + * + * @return allowNullableFields + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ALLOW_NULLABLE_FIELDS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Boolean getAllowNullableFields() { + return allowNullableFields; + } + + public void setAllowNullableFields(Boolean allowNullableFields) { + this.allowNullableFields = allowNullableFields; + } + + public ObservabilityPipelineClickhouseDestinationBatchEncoding codec( + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec codec) { + this.codec = codec; + this.unparsed |= !codec.isValid(); + return this; + } + + /** + * The codec used for batch encoding. Only arrow_stream is supported. + * + * @return codec + */ + @JsonProperty(JSON_PROPERTY_CODEC) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineClickhouseDestinationBatchEncodingCodec getCodec() { + return codec; + } + + public void setCodec(ObservabilityPipelineClickhouseDestinationBatchEncodingCodec codec) { + if (!codec.isValid()) { + this.unparsed = true; + } + this.codec = codec; + } + + /** + * 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 ObservabilityPipelineClickhouseDestinationBatchEncoding + */ + @JsonAnySetter + public ObservabilityPipelineClickhouseDestinationBatchEncoding 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 ObservabilityPipelineClickhouseDestinationBatchEncoding object is equal to + * o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineClickhouseDestinationBatchEncoding + observabilityPipelineClickhouseDestinationBatchEncoding = + (ObservabilityPipelineClickhouseDestinationBatchEncoding) o; + return Objects.equals( + this.allowNullableFields, + observabilityPipelineClickhouseDestinationBatchEncoding.allowNullableFields) + && Objects.equals(this.codec, observabilityPipelineClickhouseDestinationBatchEncoding.codec) + && Objects.equals( + this.additionalProperties, + observabilityPipelineClickhouseDestinationBatchEncoding.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(allowNullableFields, codec, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineClickhouseDestinationBatchEncoding {\n"); + sb.append(" allowNullableFields: ") + .append(toIndentedString(allowNullableFields)) + .append("\n"); + sb.append(" codec: ").append(toIndentedString(codec)).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/ObservabilityPipelineClickhouseDestinationBatchEncodingCodec.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatchEncodingCodec.java new file mode 100644 index 00000000000..4e36a7ad379 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationBatchEncodingCodec.java @@ -0,0 +1,65 @@ +/* + * 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 codec used for batch encoding. Only arrow_stream is supported. */ +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec + .ObservabilityPipelineClickhouseDestinationBatchEncodingCodecSerializer.class) +public class ObservabilityPipelineClickhouseDestinationBatchEncodingCodec + extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("arrow_stream")); + + public static final ObservabilityPipelineClickhouseDestinationBatchEncodingCodec ARROW_STREAM = + new ObservabilityPipelineClickhouseDestinationBatchEncodingCodec("arrow_stream"); + + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineClickhouseDestinationBatchEncodingCodecSerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationBatchEncodingCodecSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationBatchEncodingCodecSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationBatchEncodingCodec value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineClickhouseDestinationBatchEncodingCodec fromValue( + String value) { + return new ObservabilityPipelineClickhouseDestinationBatchEncodingCodec(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompression.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompression.java new file mode 100644 index 00000000000..9182d6c4c28 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompression.java @@ -0,0 +1,360 @@ +/* + * 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 = + ObservabilityPipelineClickhouseDestinationCompression + .ObservabilityPipelineClickhouseDestinationCompressionDeserializer.class) +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationCompression + .ObservabilityPipelineClickhouseDestinationCompressionSerializer.class) +public class ObservabilityPipelineClickhouseDestinationCompression extends AbstractOpenApiSchema { + private static final Logger log = + Logger.getLogger(ObservabilityPipelineClickhouseDestinationCompression.class.getName()); + + @JsonIgnore public boolean unparsed = false; + + public static class ObservabilityPipelineClickhouseDestinationCompressionSerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationCompressionSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationCompressionSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationCompression value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.getActualInstance()); + } + } + + public static class ObservabilityPipelineClickhouseDestinationCompressionDeserializer + extends StdDeserializer { + public ObservabilityPipelineClickhouseDestinationCompressionDeserializer() { + this(ObservabilityPipelineClickhouseDestinationCompression.class); + } + + public ObservabilityPipelineClickhouseDestinationCompressionDeserializer(Class vc) { + super(vc); + } + + @Override + public ObservabilityPipelineClickhouseDestinationCompression 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 ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Integer.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Long.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Float.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Double.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Boolean.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Integer.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class + .equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Float.class) + || ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class + .equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class.equals( + String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.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. + deserialized = tmp; + match++; + + log.log( + Level.FINER, + "Input data matches schema" + + " 'ObservabilityPipelineClickhouseDestinationCompressionAlgorithm'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'ObservabilityPipelineClickhouseDestinationCompressionAlgorithm'", + e); + } + + // deserialize ObservabilityPipelineClickhouseDestinationCompressionObject + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals(Integer.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals(Long.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals(Float.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Double.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Boolean.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Integer.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Float.class) + || ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestinationCompressionObject.class.equals( + String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(ObservabilityPipelineClickhouseDestinationCompressionObject.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 (!((ObservabilityPipelineClickhouseDestinationCompressionObject) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema" + + " 'ObservabilityPipelineClickhouseDestinationCompressionObject'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'ObservabilityPipelineClickhouseDestinationCompressionObject'", + e); + } + + ObservabilityPipelineClickhouseDestinationCompression ret = + new ObservabilityPipelineClickhouseDestinationCompression(); + 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 ObservabilityPipelineClickhouseDestinationCompression getNullValue( + DeserializationContext ctxt) throws JsonMappingException { + throw new JsonMappingException( + ctxt.getParser(), "ObservabilityPipelineClickhouseDestinationCompression cannot be null"); + } + } + + // store a list of schema names defined in oneOf + public static final Map schemas = new HashMap(); + + public ObservabilityPipelineClickhouseDestinationCompression() { + super("oneOf", Boolean.FALSE); + } + + public ObservabilityPipelineClickhouseDestinationCompression( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public ObservabilityPipelineClickhouseDestinationCompression( + ObservabilityPipelineClickhouseDestinationCompressionObject o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + static { + schemas.put( + "ObservabilityPipelineClickhouseDestinationCompressionAlgorithm", + new GenericType() {}); + schemas.put( + "ObservabilityPipelineClickhouseDestinationCompressionObject", + new GenericType() {}); + JSON.registerDescendants( + ObservabilityPipelineClickhouseDestinationCompression.class, + Collections.unmodifiableMap(schemas)); + } + + @Override + public Map getSchemas() { + return ObservabilityPipelineClickhouseDestinationCompression.schemas; + } + + /** + * Set the instance that matches the oneOf child schema, check the instance parameter is valid + * against the oneOf child schemas: + * ObservabilityPipelineClickhouseDestinationCompressionAlgorithm, + * ObservabilityPipelineClickhouseDestinationCompressionObject + * + *

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( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + ObservabilityPipelineClickhouseDestinationCompressionObject.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" + + " ObservabilityPipelineClickhouseDestinationCompressionAlgorithm," + + " ObservabilityPipelineClickhouseDestinationCompressionObject"); + } + + /** + * Get the actual instance, which can be the following: + * ObservabilityPipelineClickhouseDestinationCompressionAlgorithm, + * ObservabilityPipelineClickhouseDestinationCompressionObject + * + * @return The actual instance (ObservabilityPipelineClickhouseDestinationCompressionAlgorithm, + * ObservabilityPipelineClickhouseDestinationCompressionObject) + */ + @Override + public Object getActualInstance() { + return super.getActualInstance(); + } + + /** + * Get the actual instance of `ObservabilityPipelineClickhouseDestinationCompressionAlgorithm`. If + * the actual instance is not `ObservabilityPipelineClickhouseDestinationCompressionAlgorithm`, + * the ClassCastException will be thrown. + * + * @return The actual instance of `ObservabilityPipelineClickhouseDestinationCompressionAlgorithm` + * @throws ClassCastException if the instance is not + * `ObservabilityPipelineClickhouseDestinationCompressionAlgorithm` + */ + public ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + getObservabilityPipelineClickhouseDestinationCompressionAlgorithm() + throws ClassCastException { + return (ObservabilityPipelineClickhouseDestinationCompressionAlgorithm) + super.getActualInstance(); + } + + /** + * Get the actual instance of `ObservabilityPipelineClickhouseDestinationCompressionObject`. If + * the actual instance is not `ObservabilityPipelineClickhouseDestinationCompressionObject`, the + * ClassCastException will be thrown. + * + * @return The actual instance of `ObservabilityPipelineClickhouseDestinationCompressionObject` + * @throws ClassCastException if the instance is not + * `ObservabilityPipelineClickhouseDestinationCompressionObject` + */ + public ObservabilityPipelineClickhouseDestinationCompressionObject + getObservabilityPipelineClickhouseDestinationCompressionObject() throws ClassCastException { + return (ObservabilityPipelineClickhouseDestinationCompressionObject) super.getActualInstance(); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.java new file mode 100644 index 00000000000..e8721793a27 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionAlgorithm.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 compression algorithm applied to outbound HTTP requests. */ +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + .ObservabilityPipelineClickhouseDestinationCompressionAlgorithmSerializer.class) +public class ObservabilityPipelineClickhouseDestinationCompressionAlgorithm + extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("gzip", "none")); + + public static final ObservabilityPipelineClickhouseDestinationCompressionAlgorithm GZIP = + new ObservabilityPipelineClickhouseDestinationCompressionAlgorithm("gzip"); + public static final ObservabilityPipelineClickhouseDestinationCompressionAlgorithm NONE = + new ObservabilityPipelineClickhouseDestinationCompressionAlgorithm("none"); + + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineClickhouseDestinationCompressionAlgorithmSerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationCompressionAlgorithmSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationCompressionAlgorithmSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineClickhouseDestinationCompressionAlgorithm fromValue( + String value) { + return new ObservabilityPipelineClickhouseDestinationCompressionAlgorithm(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionObject.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionObject.java new file mode 100644 index 00000000000..65d165c46a7 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationCompressionObject.java @@ -0,0 +1,195 @@ +/* + * 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; + +/** + * Structured compression configuration for the ClickHouse destination. Use algorithm + * to specify the compression type and level (optional, gzip only) to control + * compression strength. + */ +@JsonPropertyOrder({ + ObservabilityPipelineClickhouseDestinationCompressionObject.JSON_PROPERTY_ALGORITHM, + ObservabilityPipelineClickhouseDestinationCompressionObject.JSON_PROPERTY_LEVEL +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineClickhouseDestinationCompressionObject { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ALGORITHM = "algorithm"; + private ObservabilityPipelineClickhouseDestinationCompressionAlgorithm algorithm; + + public static final String JSON_PROPERTY_LEVEL = "level"; + private Long level; + + public ObservabilityPipelineClickhouseDestinationCompressionObject() {} + + @JsonCreator + public ObservabilityPipelineClickhouseDestinationCompressionObject( + @JsonProperty(required = true, value = JSON_PROPERTY_ALGORITHM) + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm algorithm) { + this.algorithm = algorithm; + this.unparsed |= !algorithm.isValid(); + } + + public ObservabilityPipelineClickhouseDestinationCompressionObject algorithm( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm algorithm) { + this.algorithm = algorithm; + this.unparsed |= !algorithm.isValid(); + return this; + } + + /** + * The compression algorithm applied to outbound HTTP requests. + * + * @return algorithm + */ + @JsonProperty(JSON_PROPERTY_ALGORITHM) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineClickhouseDestinationCompressionAlgorithm getAlgorithm() { + return algorithm; + } + + public void setAlgorithm( + ObservabilityPipelineClickhouseDestinationCompressionAlgorithm algorithm) { + if (!algorithm.isValid()) { + this.unparsed = true; + } + this.algorithm = algorithm; + } + + public ObservabilityPipelineClickhouseDestinationCompressionObject level(Long level) { + this.level = level; + return this; + } + + /** + * Compression level (1–9). Only applicable when algorithm is gzip. + * minimum: 1 maximum: 9 + * + * @return level + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_LEVEL) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Long getLevel() { + return level; + } + + public void setLevel(Long level) { + this.level = level; + } + + /** + * 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 ObservabilityPipelineClickhouseDestinationCompressionObject + */ + @JsonAnySetter + public ObservabilityPipelineClickhouseDestinationCompressionObject 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 ObservabilityPipelineClickhouseDestinationCompressionObject object is equal + * to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineClickhouseDestinationCompressionObject + observabilityPipelineClickhouseDestinationCompressionObject = + (ObservabilityPipelineClickhouseDestinationCompressionObject) o; + return Objects.equals( + this.algorithm, observabilityPipelineClickhouseDestinationCompressionObject.algorithm) + && Objects.equals( + this.level, observabilityPipelineClickhouseDestinationCompressionObject.level) + && Objects.equals( + this.additionalProperties, + observabilityPipelineClickhouseDestinationCompressionObject.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(algorithm, level, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineClickhouseDestinationCompressionObject {\n"); + sb.append(" algorithm: ").append(toIndentedString(algorithm)).append("\n"); + sb.append(" level: ").append(toIndentedString(level)).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/ObservabilityPipelineClickhouseDestinationFormat.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationFormat.java new file mode 100644 index 00000000000..3e3705a50c5 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationFormat.java @@ -0,0 +1,78 @@ +/* + * 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; + +/** + * Insert format for events sent to ClickHouse. - json_each_row: Maps event fields to + * columns by name (ClickHouse JSONEachRow). - json_as_object: Inserts + * each event into a single Object('json') / JSON column (ClickHouse + * JSONAsObject). - json_as_string: Inserts each event into a single + * String-typed column as raw JSON (ClickHouse JSONAsString). - + * arrow_stream: Batches events using Apache Arrow IPC streaming format. Requires + * batch_encoding. + */ +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationFormat + .ObservabilityPipelineClickhouseDestinationFormatSerializer.class) +public class ObservabilityPipelineClickhouseDestinationFormat extends ModelEnum { + + private static final Set allowedValues = + new HashSet( + Arrays.asList("json_each_row", "json_as_object", "json_as_string", "arrow_stream")); + + public static final ObservabilityPipelineClickhouseDestinationFormat JSON_EACH_ROW = + new ObservabilityPipelineClickhouseDestinationFormat("json_each_row"); + public static final ObservabilityPipelineClickhouseDestinationFormat JSON_AS_OBJECT = + new ObservabilityPipelineClickhouseDestinationFormat("json_as_object"); + public static final ObservabilityPipelineClickhouseDestinationFormat JSON_AS_STRING = + new ObservabilityPipelineClickhouseDestinationFormat("json_as_string"); + public static final ObservabilityPipelineClickhouseDestinationFormat ARROW_STREAM = + new ObservabilityPipelineClickhouseDestinationFormat("arrow_stream"); + + ObservabilityPipelineClickhouseDestinationFormat(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineClickhouseDestinationFormatSerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationFormatSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationFormatSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationFormat value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineClickhouseDestinationFormat fromValue(String value) { + return new ObservabilityPipelineClickhouseDestinationFormat(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationType.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationType.java new file mode 100644 index 00000000000..226023e452b --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineClickhouseDestinationType.java @@ -0,0 +1,62 @@ +/* + * 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 destination type. The value must be clickhouse. */ +@JsonSerialize( + using = + ObservabilityPipelineClickhouseDestinationType + .ObservabilityPipelineClickhouseDestinationTypeSerializer.class) +public class ObservabilityPipelineClickhouseDestinationType extends ModelEnum { + + private static final Set allowedValues = new HashSet(Arrays.asList("clickhouse")); + + public static final ObservabilityPipelineClickhouseDestinationType CLICKHOUSE = + new ObservabilityPipelineClickhouseDestinationType("clickhouse"); + + ObservabilityPipelineClickhouseDestinationType(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineClickhouseDestinationTypeSerializer + extends StdSerializer { + public ObservabilityPipelineClickhouseDestinationTypeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineClickhouseDestinationTypeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineClickhouseDestinationType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineClickhouseDestinationType fromValue(String value) { + return new ObservabilityPipelineClickhouseDestinationType(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigDestinationItem.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigDestinationItem.java index 5193145c7e6..fb68db07218 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigDestinationItem.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigDestinationItem.java @@ -451,6 +451,58 @@ public ObservabilityPipelineConfigDestinationItem deserialize( log.log(Level.FINER, "Input data does not match schema 'AzureStorageDestination'", e); } + // deserialize ObservabilityPipelineClickhouseDestination + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineClickhouseDestination.class.equals(Integer.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Long.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Float.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Double.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Boolean.class) + || ObservabilityPipelineClickhouseDestination.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineClickhouseDestination.class.equals(Integer.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineClickhouseDestination.class.equals(Float.class) + || ObservabilityPipelineClickhouseDestination.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestination.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineClickhouseDestination.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(ObservabilityPipelineClickhouseDestination.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 (!((ObservabilityPipelineClickhouseDestination) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'ObservabilityPipelineClickhouseDestination'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'ObservabilityPipelineClickhouseDestination'", + e); + } + // deserialize ObservabilityPipelineCloudPremDestination try { boolean attemptParsing = true; @@ -1503,6 +1555,11 @@ public ObservabilityPipelineConfigDestinationItem(AzureStorageDestination o) { setActualInstance(o); } + public ObservabilityPipelineConfigDestinationItem(ObservabilityPipelineClickhouseDestination o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + public ObservabilityPipelineConfigDestinationItem(ObservabilityPipelineCloudPremDestination o) { super("oneOf", Boolean.FALSE); setActualInstance(o); @@ -1625,6 +1682,9 @@ public ObservabilityPipelineConfigDestinationItem( "ObservabilityPipelineAmazonSecurityLakeDestination", new GenericType() {}); schemas.put("AzureStorageDestination", new GenericType() {}); + schemas.put( + "ObservabilityPipelineClickhouseDestination", + new GenericType() {}); schemas.put( "ObservabilityPipelineCloudPremDestination", new GenericType() {}); @@ -1695,7 +1755,7 @@ public Map getSchemas() { * ObservabilityPipelineHttpClientDestination, ObservabilityPipelineAmazonOpenSearchDestination, * ObservabilityPipelineAmazonS3Destination, ObservabilityPipelineAmazonS3GenericDestination, * ObservabilityPipelineAmazonSecurityLakeDestination, AzureStorageDestination, - * ObservabilityPipelineCloudPremDestination, + * ObservabilityPipelineClickhouseDestination, ObservabilityPipelineCloudPremDestination, * ObservabilityPipelineCrowdStrikeNextGenSiemDestination, * ObservabilityPipelineDatadogLogsDestination, ObservabilityPipelineGoogleChronicleDestination, * ObservabilityPipelineGoogleCloudStorageDestination, @@ -1751,6 +1811,11 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + ObservabilityPipelineClickhouseDestination.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf( ObservabilityPipelineCloudPremDestination.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -1865,6 +1930,7 @@ public void setActualInstance(Object instance) { + " ObservabilityPipelineAmazonS3Destination," + " ObservabilityPipelineAmazonS3GenericDestination," + " ObservabilityPipelineAmazonSecurityLakeDestination, AzureStorageDestination," + + " ObservabilityPipelineClickhouseDestination," + " ObservabilityPipelineCloudPremDestination," + " ObservabilityPipelineCrowdStrikeNextGenSiemDestination," + " ObservabilityPipelineDatadogLogsDestination," @@ -1890,7 +1956,7 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineAmazonOpenSearchDestination, ObservabilityPipelineAmazonS3Destination, * ObservabilityPipelineAmazonS3GenericDestination, * ObservabilityPipelineAmazonSecurityLakeDestination, AzureStorageDestination, - * ObservabilityPipelineCloudPremDestination, + * ObservabilityPipelineClickhouseDestination, ObservabilityPipelineCloudPremDestination, * ObservabilityPipelineCrowdStrikeNextGenSiemDestination, * ObservabilityPipelineDatadogLogsDestination, ObservabilityPipelineGoogleChronicleDestination, * ObservabilityPipelineGoogleCloudStorageDestination, @@ -1908,7 +1974,7 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineAmazonOpenSearchDestination, ObservabilityPipelineAmazonS3Destination, * ObservabilityPipelineAmazonS3GenericDestination, * ObservabilityPipelineAmazonSecurityLakeDestination, AzureStorageDestination, - * ObservabilityPipelineCloudPremDestination, + * ObservabilityPipelineClickhouseDestination, ObservabilityPipelineCloudPremDestination, * ObservabilityPipelineCrowdStrikeNextGenSiemDestination, * ObservabilityPipelineDatadogLogsDestination, * ObservabilityPipelineGoogleChronicleDestination, @@ -2019,6 +2085,18 @@ public AzureStorageDestination getAzureStorageDestination() throws ClassCastExce return (AzureStorageDestination) super.getActualInstance(); } + /** + * Get the actual instance of `ObservabilityPipelineClickhouseDestination`. If the actual instance + * is not `ObservabilityPipelineClickhouseDestination`, the ClassCastException will be thrown. + * + * @return The actual instance of `ObservabilityPipelineClickhouseDestination` + * @throws ClassCastException if the instance is not `ObservabilityPipelineClickhouseDestination` + */ + public ObservabilityPipelineClickhouseDestination getObservabilityPipelineClickhouseDestination() + throws ClassCastException { + return (ObservabilityPipelineClickhouseDestination) super.getActualInstance(); + } + /** * Get the actual instance of `ObservabilityPipelineCloudPremDestination`. If the actual instance * is not `ObservabilityPipelineCloudPremDestination`, the ClassCastException will be thrown. diff --git a/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.freeze b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.freeze new file mode 100644 index 00000000000..663907587bf --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.freeze @@ -0,0 +1 @@ +2026-06-22T20:44:30.778Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.json b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.json new file mode 100644 index 00000000000..9ad20cf1cc6 --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_arrow_stream_format_returns_OK_response.json @@ -0,0 +1,32 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"data\":{\"attributes\":{\"config\":{\"destinations\":[{\"auth\":{\"password_key\":\"CLICKHOUSE_PASSWORD\",\"strategy\":\"basic\",\"username_key\":\"CLICKHOUSE_USERNAME\"},\"batch\":{\"max_events\":1000,\"timeout_secs\":1},\"batch_encoding\":{\"allow_nullable_fields\":false,\"codec\":\"arrow_stream\"},\"compression\":\"gzip\",\"database\":\"my_database\",\"format\":\"arrow_stream\",\"id\":\"clickhouse-destination\",\"inputs\":[\"my-processor-group\"],\"table\":\"application_logs\",\"type\":\"clickhouse\"}],\"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 ClickHouse Destination Arrow Stream\"},\"type\":\"pipelines\"}}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v2/obs-pipelines/pipelines/validate", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"errors\":[]}\n", + "headers": { + "Content-Type": [ + "application/vnd.api+json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "25c696a6-8c82-1ece-cdcc-006c2bc4c03c" + } +] \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.freeze b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.freeze new file mode 100644 index 00000000000..9b0a4331860 --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.freeze @@ -0,0 +1 @@ +2026-06-22T20:44:32.514Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.json b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.json new file mode 100644 index 00000000000..f031484eacc --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Validate_an_observability_pipeline_with_ClickHouse_destination_returns_OK_response.json @@ -0,0 +1,32 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"data\":{\"attributes\":{\"config\":{\"destinations\":[{\"auth\":{\"password_key\":\"CLICKHOUSE_PASSWORD\",\"strategy\":\"basic\",\"username_key\":\"CLICKHOUSE_USERNAME\"},\"batch\":{\"max_events\":1000,\"timeout_secs\":1},\"compression\":\"gzip\",\"database\":\"my_database\",\"id\":\"clickhouse-destination\",\"inputs\":[\"my-processor-group\"],\"table\":\"application_logs\",\"type\":\"clickhouse\"}],\"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 ClickHouse Destination\"},\"type\":\"pipelines\"}}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v2/obs-pipelines/pipelines/validate", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"errors\":[]}\n", + "headers": { + "Content-Type": [ + "application/vnd.api+json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "63e4c22a-5925-ee0d-753b-871b68e22ab3" + } +] \ No newline at end of file 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 487d6971f82..a57aed2a032 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 @@ -176,6 +176,22 @@ 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 ClickHouse destination arrow_stream format returns "OK" response + Given new "ValidatePipeline" request + And body with value {"data": {"attributes": {"config": {"destinations": [{"id": "clickhouse-destination", "inputs": ["my-processor-group"], "type": "clickhouse", "table": "application_logs", "database": "my_database", "format": "arrow_stream", "batch_encoding": {"codec": "arrow_stream", "allow_nullable_fields": false}, "compression": "gzip", "auth": {"strategy": "basic", "username_key": "CLICKHOUSE_USERNAME", "password_key": "CLICKHOUSE_PASSWORD"}, "batch": {"max_events": 1000, "timeout_secs": 1}}], "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 ClickHouse Destination Arrow Stream"}, "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 ClickHouse destination returns "OK" response + Given new "ValidatePipeline" request + And body with value {"data": {"attributes": {"config": {"destinations": [{"id": "clickhouse-destination", "inputs": ["my-processor-group"], "type": "clickhouse", "table": "application_logs", "database": "my_database", "compression": "gzip", "auth": {"strategy": "basic", "username_key": "CLICKHOUSE_USERNAME", "password_key": "CLICKHOUSE_PASSWORD"}, "batch": {"max_events": 1000, "timeout_secs": 1}}], "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 ClickHouse Destination"}, "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 HTTP server source valid_tokens returns "OK" response Given new "ValidatePipeline" request