diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index 8c4bbdb2187..d3016c41cbe 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -7534,6 +7534,104 @@ components: - data_source - query type: object + MonitorFormulaAndFunctionDataQualityDataSource: + description: Data source for data quality queries. + enum: + - data_quality_metrics + example: data_quality_metrics + type: string + x-enum-varnames: + - DATA_QUALITY_METRICS + MonitorFormulaAndFunctionDataQualityMeasure: + description: 'The data quality measure to query. Common values include: + + `bytes`, `cardinality`, `custom`, `freshness`, `max`, `mean`, `min`, + + `nullness`, `percent_negative`, `percent_zero`, `row_count`, `stddev`, + + `sum`, `uniqueness`. Additional values may be supported.' + example: row_count + type: string + MonitorFormulaAndFunctionDataQualityModelTypeOverride: + description: Override for the model type used in anomaly detection. + enum: + - freshness + - percentage + - any + type: string + x-enum-varnames: + - FRESHNESS + - PERCENTAGE + - ANY + MonitorFormulaAndFunctionDataQualityMonitorOptions: + description: Monitor configuration options for data quality queries. + properties: + crontab_override: + description: Crontab expression to override the default schedule. + example: '* * * 10' + type: string + custom_sql: + description: Custom SQL query for the monitor. + example: SELECT COUNT(*) FROM users AS dd_value + type: string + custom_where: + description: Custom WHERE clause for the query. + example: USER_ID = 123 + type: string + group_by_columns: + description: Columns to group results by. + example: + - col1 + - col2 + items: + type: string + type: array + model_type_override: + $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityModelTypeOverride' + type: object + MonitorFormulaAndFunctionDataQualityQueryDefinition: + description: A formula and functions data quality query. + properties: + data_source: + $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityDataSource' + filter: + description: Filter expression used to match on data entities. Uses Aastra + query syntax. + example: search for column where `database:production AND table:users` + type: string + group_by: + description: Optional grouping fields for aggregation. + example: + - entity_id + items: + type: string + type: array + measure: + $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityMeasure' + monitor_options: + $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityMonitorOptions' + name: + description: Name of the query for use in formulas. + example: query1 + type: string + schema_version: + description: Schema version for the data quality query. + example: 0.0.1 + type: string + scope: + description: 'Optional scoping expression to further filter metrics. Uses + metrics filter syntax. + + This is useful when an entity has been configured to emit metrics with + additional tags.' + example: env:production + type: string + required: + - name + - data_source + - measure + - filter + type: object MonitorFormulaAndFunctionEventAggregation: description: Aggregation methods for event platform queries. enum: @@ -7685,6 +7783,7 @@ components: oneOf: - $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinition' - $ref: '#/components/schemas/MonitorFormulaAndFunctionCostQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityQueryDefinition' MonitorGroupSearchResponse: description: The response of a monitor group search. example: @@ -8523,6 +8622,7 @@ components: - database-monitoring alert - network-performance alert - cost alert + - data-quality alert example: query alert type: string x-enum-varnames: @@ -8545,6 +8645,7 @@ components: - DATABASE_MONITORING_ALERT - NETWORK_PERFORMANCE_ALERT - COST_ALERT + - DATA_QUALITY_ALERT MonitorUpdateRequest: description: Object describing a monitor update request. properties: diff --git a/examples/v1/monitors/CreateMonitor_3626832481.java b/examples/v1/monitors/CreateMonitor_3626832481.java new file mode 100644 index 00000000000..100a0990f11 --- /dev/null +++ b/examples/v1/monitors/CreateMonitor_3626832481.java @@ -0,0 +1,59 @@ +// Create a Data Quality monitor returns "OK" response + +import com.datadog.api.client.ApiClient; +import com.datadog.api.client.ApiException; +import com.datadog.api.client.v1.api.MonitorsApi; +import com.datadog.api.client.v1.model.Monitor; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionQueryDefinition; +import com.datadog.api.client.v1.model.MonitorOptions; +import com.datadog.api.client.v1.model.MonitorThresholds; +import com.datadog.api.client.v1.model.MonitorType; +import java.util.Arrays; +import java.util.Collections; + +public class Example { + public static void main(String[] args) { + ApiClient defaultClient = ApiClient.getDefaultApiClient(); + MonitorsApi apiInstance = new MonitorsApi(defaultClient); + + Monitor body = + new Monitor() + .name("Example-Monitor") + .type(MonitorType.DATA_QUALITY_ALERT) + .query(""" +formula("query1").last("5m") > 100 +""") + .message("Data quality alert triggered") + .tags(Arrays.asList("test:examplemonitor", "env:ci")) + .priority(3L) + .options( + new MonitorOptions() + .thresholds(new MonitorThresholds().critical(100.0)) + .variables( + Collections.singletonList( + new MonitorFormulaAndFunctionQueryDefinition( + new MonitorFormulaAndFunctionDataQualityQueryDefinition() + .name("query1") + .dataSource( + MonitorFormulaAndFunctionDataQualityDataSource + .DATA_QUALITY_METRICS) + .measure("row_count") + .filter( + "search for column where `database:production AND" + + " table:users`") + .groupBy(Collections.singletonList("entity_id")))))); + + try { + Monitor result = apiInstance.createMonitor(body); + System.out.println(result); + } catch (ApiException e) { + System.err.println("Exception when calling MonitorsApi#createMonitor"); + 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/v1/model/MonitorFormulaAndFunctionDataQualityDataSource.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDataSource.java new file mode 100644 index 00000000000..a62c36e9ea0 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDataSource.java @@ -0,0 +1,63 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v1.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; + +/** Data source for data quality queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionDataQualityDataSource + .MonitorFormulaAndFunctionDataQualityDataSourceSerializer.class) +public class MonitorFormulaAndFunctionDataQualityDataSource extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("data_quality_metrics")); + + public static final MonitorFormulaAndFunctionDataQualityDataSource DATA_QUALITY_METRICS = + new MonitorFormulaAndFunctionDataQualityDataSource("data_quality_metrics"); + + MonitorFormulaAndFunctionDataQualityDataSource(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionDataQualityDataSourceSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionDataQualityDataSourceSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionDataQualityDataSourceSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionDataQualityDataSource value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionDataQualityDataSource fromValue(String value) { + return new MonitorFormulaAndFunctionDataQualityDataSource(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelTypeOverride.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelTypeOverride.java new file mode 100644 index 00000000000..c2e38290731 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelTypeOverride.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.v1.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; + +/** Override for the model type used in anomaly detection. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionDataQualityModelTypeOverride + .MonitorFormulaAndFunctionDataQualityModelTypeOverrideSerializer.class) +public class MonitorFormulaAndFunctionDataQualityModelTypeOverride extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("freshness", "percentage", "any")); + + public static final MonitorFormulaAndFunctionDataQualityModelTypeOverride FRESHNESS = + new MonitorFormulaAndFunctionDataQualityModelTypeOverride("freshness"); + public static final MonitorFormulaAndFunctionDataQualityModelTypeOverride PERCENTAGE = + new MonitorFormulaAndFunctionDataQualityModelTypeOverride("percentage"); + public static final MonitorFormulaAndFunctionDataQualityModelTypeOverride ANY = + new MonitorFormulaAndFunctionDataQualityModelTypeOverride("any"); + + MonitorFormulaAndFunctionDataQualityModelTypeOverride(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionDataQualityModelTypeOverrideSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionDataQualityModelTypeOverrideSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionDataQualityModelTypeOverrideSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionDataQualityModelTypeOverride value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionDataQualityModelTypeOverride fromValue(String value) { + return new MonitorFormulaAndFunctionDataQualityModelTypeOverride(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java new file mode 100644 index 00000000000..b025eb72f83 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java @@ -0,0 +1,284 @@ +/* + * 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.v1.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.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** Monitor configuration options for data quality queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_CRONTAB_OVERRIDE, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_CUSTOM_SQL, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_CUSTOM_WHERE, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_GROUP_BY_COLUMNS, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_MODEL_TYPE_OVERRIDE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionDataQualityMonitorOptions { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_CRONTAB_OVERRIDE = "crontab_override"; + private String crontabOverride; + + public static final String JSON_PROPERTY_CUSTOM_SQL = "custom_sql"; + private String customSql; + + public static final String JSON_PROPERTY_CUSTOM_WHERE = "custom_where"; + private String customWhere; + + public static final String JSON_PROPERTY_GROUP_BY_COLUMNS = "group_by_columns"; + private List groupByColumns = null; + + public static final String JSON_PROPERTY_MODEL_TYPE_OVERRIDE = "model_type_override"; + private MonitorFormulaAndFunctionDataQualityModelTypeOverride modelTypeOverride; + + public MonitorFormulaAndFunctionDataQualityMonitorOptions crontabOverride( + String crontabOverride) { + this.crontabOverride = crontabOverride; + return this; + } + + /** + * Crontab expression to override the default schedule. + * + * @return crontabOverride + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_CRONTAB_OVERRIDE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getCrontabOverride() { + return crontabOverride; + } + + public void setCrontabOverride(String crontabOverride) { + this.crontabOverride = crontabOverride; + } + + public MonitorFormulaAndFunctionDataQualityMonitorOptions customSql(String customSql) { + this.customSql = customSql; + return this; + } + + /** + * Custom SQL query for the monitor. + * + * @return customSql + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_CUSTOM_SQL) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getCustomSql() { + return customSql; + } + + public void setCustomSql(String customSql) { + this.customSql = customSql; + } + + public MonitorFormulaAndFunctionDataQualityMonitorOptions customWhere(String customWhere) { + this.customWhere = customWhere; + return this; + } + + /** + * Custom WHERE clause for the query. + * + * @return customWhere + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_CUSTOM_WHERE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getCustomWhere() { + return customWhere; + } + + public void setCustomWhere(String customWhere) { + this.customWhere = customWhere; + } + + public MonitorFormulaAndFunctionDataQualityMonitorOptions groupByColumns( + List groupByColumns) { + this.groupByColumns = groupByColumns; + return this; + } + + public MonitorFormulaAndFunctionDataQualityMonitorOptions addGroupByColumnsItem( + String groupByColumnsItem) { + if (this.groupByColumns == null) { + this.groupByColumns = new ArrayList<>(); + } + this.groupByColumns.add(groupByColumnsItem); + return this; + } + + /** + * Columns to group results by. + * + * @return groupByColumns + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_GROUP_BY_COLUMNS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getGroupByColumns() { + return groupByColumns; + } + + public void setGroupByColumns(List groupByColumns) { + this.groupByColumns = groupByColumns; + } + + public MonitorFormulaAndFunctionDataQualityMonitorOptions modelTypeOverride( + MonitorFormulaAndFunctionDataQualityModelTypeOverride modelTypeOverride) { + this.modelTypeOverride = modelTypeOverride; + this.unparsed |= !modelTypeOverride.isValid(); + return this; + } + + /** + * Override for the model type used in anomaly detection. + * + * @return modelTypeOverride + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MODEL_TYPE_OVERRIDE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualityModelTypeOverride getModelTypeOverride() { + return modelTypeOverride; + } + + public void setModelTypeOverride( + MonitorFormulaAndFunctionDataQualityModelTypeOverride modelTypeOverride) { + if (!modelTypeOverride.isValid()) { + this.unparsed = true; + } + this.modelTypeOverride = modelTypeOverride; + } + + /** + * 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 MonitorFormulaAndFunctionDataQualityMonitorOptions + */ + @JsonAnySetter + public MonitorFormulaAndFunctionDataQualityMonitorOptions 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 MonitorFormulaAndFunctionDataQualityMonitorOptions object is equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionDataQualityMonitorOptions + monitorFormulaAndFunctionDataQualityMonitorOptions = + (MonitorFormulaAndFunctionDataQualityMonitorOptions) o; + return Objects.equals( + this.crontabOverride, + monitorFormulaAndFunctionDataQualityMonitorOptions.crontabOverride) + && Objects.equals( + this.customSql, monitorFormulaAndFunctionDataQualityMonitorOptions.customSql) + && Objects.equals( + this.customWhere, monitorFormulaAndFunctionDataQualityMonitorOptions.customWhere) + && Objects.equals( + this.groupByColumns, monitorFormulaAndFunctionDataQualityMonitorOptions.groupByColumns) + && Objects.equals( + this.modelTypeOverride, + monitorFormulaAndFunctionDataQualityMonitorOptions.modelTypeOverride) + && Objects.equals( + this.additionalProperties, + monitorFormulaAndFunctionDataQualityMonitorOptions.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + crontabOverride, + customSql, + customWhere, + groupByColumns, + modelTypeOverride, + additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionDataQualityMonitorOptions {\n"); + sb.append(" crontabOverride: ").append(toIndentedString(crontabOverride)).append("\n"); + sb.append(" customSql: ").append(toIndentedString(customSql)).append("\n"); + sb.append(" customWhere: ").append(toIndentedString(customWhere)).append("\n"); + sb.append(" groupByColumns: ").append(toIndentedString(groupByColumns)).append("\n"); + sb.append(" modelTypeOverride: ").append(toIndentedString(modelTypeOverride)).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/v1/model/MonitorFormulaAndFunctionDataQualityQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityQueryDefinition.java new file mode 100644 index 00000000000..39f0230617c --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityQueryDefinition.java @@ -0,0 +1,380 @@ +/* + * 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.v1.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; + +/** A formula and functions data quality query. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_DATA_SOURCE, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_FILTER, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_GROUP_BY, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_MEASURE, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_MONITOR_OPTIONS, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_NAME, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_SCHEMA_VERSION, + MonitorFormulaAndFunctionDataQualityQueryDefinition.JSON_PROPERTY_SCOPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionDataQualityQueryDefinition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_DATA_SOURCE = "data_source"; + private MonitorFormulaAndFunctionDataQualityDataSource dataSource; + + public static final String JSON_PROPERTY_FILTER = "filter"; + private String filter; + + public static final String JSON_PROPERTY_GROUP_BY = "group_by"; + private List groupBy = null; + + public static final String JSON_PROPERTY_MEASURE = "measure"; + private String measure; + + public static final String JSON_PROPERTY_MONITOR_OPTIONS = "monitor_options"; + private MonitorFormulaAndFunctionDataQualityMonitorOptions monitorOptions; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public static final String JSON_PROPERTY_SCHEMA_VERSION = "schema_version"; + private String schemaVersion; + + public static final String JSON_PROPERTY_SCOPE = "scope"; + private String scope; + + public MonitorFormulaAndFunctionDataQualityQueryDefinition() {} + + @JsonCreator + public MonitorFormulaAndFunctionDataQualityQueryDefinition( + @JsonProperty(required = true, value = JSON_PROPERTY_DATA_SOURCE) + MonitorFormulaAndFunctionDataQualityDataSource dataSource, + @JsonProperty(required = true, value = JSON_PROPERTY_FILTER) String filter, + @JsonProperty(required = true, value = JSON_PROPERTY_MEASURE) String measure, + @JsonProperty(required = true, value = JSON_PROPERTY_NAME) String name) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + this.filter = filter; + this.measure = measure; + this.name = name; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition dataSource( + MonitorFormulaAndFunctionDataQualityDataSource dataSource) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + return this; + } + + /** + * Data source for data quality queries. + * + * @return dataSource + */ + @JsonProperty(JSON_PROPERTY_DATA_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionDataQualityDataSource getDataSource() { + return dataSource; + } + + public void setDataSource(MonitorFormulaAndFunctionDataQualityDataSource dataSource) { + if (!dataSource.isValid()) { + this.unparsed = true; + } + this.dataSource = dataSource; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition filter(String filter) { + this.filter = filter; + return this; + } + + /** + * Filter expression used to match on data entities. Uses Aastra query syntax. + * + * @return filter + */ + @JsonProperty(JSON_PROPERTY_FILTER) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getFilter() { + return filter; + } + + public void setFilter(String filter) { + this.filter = filter; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition groupBy(List groupBy) { + this.groupBy = groupBy; + return this; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition addGroupByItem(String groupByItem) { + if (this.groupBy == null) { + this.groupBy = new ArrayList<>(); + } + this.groupBy.add(groupByItem); + return this; + } + + /** + * Optional grouping fields for aggregation. + * + * @return groupBy + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_GROUP_BY) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getGroupBy() { + return groupBy; + } + + public void setGroupBy(List groupBy) { + this.groupBy = groupBy; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition measure(String measure) { + this.measure = measure; + return this; + } + + /** + * The data quality measure to query. Common values include: bytes, cardinality + * , custom, freshness, max, mean, + * min, nullness, percent_negative, percent_zero + * , row_count, stddev, sum, uniqueness + * . Additional values may be supported. + * + * @return measure + */ + @JsonProperty(JSON_PROPERTY_MEASURE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getMeasure() { + return measure; + } + + public void setMeasure(String measure) { + this.measure = measure; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition monitorOptions( + MonitorFormulaAndFunctionDataQualityMonitorOptions monitorOptions) { + this.monitorOptions = monitorOptions; + this.unparsed |= monitorOptions.unparsed; + return this; + } + + /** + * Monitor configuration options for data quality queries. + * + * @return monitorOptions + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MONITOR_OPTIONS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualityMonitorOptions getMonitorOptions() { + return monitorOptions; + } + + public void setMonitorOptions(MonitorFormulaAndFunctionDataQualityMonitorOptions monitorOptions) { + this.monitorOptions = monitorOptions; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition name(String name) { + this.name = name; + return this; + } + + /** + * Name of the query for use in formulas. + * + * @return name + */ + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition schemaVersion(String schemaVersion) { + this.schemaVersion = schemaVersion; + return this; + } + + /** + * Schema version for the data quality query. + * + * @return schemaVersion + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_SCHEMA_VERSION) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getSchemaVersion() { + return schemaVersion; + } + + public void setSchemaVersion(String schemaVersion) { + this.schemaVersion = schemaVersion; + } + + public MonitorFormulaAndFunctionDataQualityQueryDefinition scope(String scope) { + this.scope = scope; + return this; + } + + /** + * Optional scoping expression to further filter metrics. Uses metrics filter syntax. This is + * useful when an entity has been configured to emit metrics with additional tags. + * + * @return scope + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_SCOPE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getScope() { + return scope; + } + + public void setScope(String scope) { + this.scope = scope; + } + + /** + * 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 MonitorFormulaAndFunctionDataQualityQueryDefinition + */ + @JsonAnySetter + public MonitorFormulaAndFunctionDataQualityQueryDefinition 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 MonitorFormulaAndFunctionDataQualityQueryDefinition object is equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionDataQualityQueryDefinition + monitorFormulaAndFunctionDataQualityQueryDefinition = + (MonitorFormulaAndFunctionDataQualityQueryDefinition) o; + return Objects.equals( + this.dataSource, monitorFormulaAndFunctionDataQualityQueryDefinition.dataSource) + && Objects.equals(this.filter, monitorFormulaAndFunctionDataQualityQueryDefinition.filter) + && Objects.equals(this.groupBy, monitorFormulaAndFunctionDataQualityQueryDefinition.groupBy) + && Objects.equals(this.measure, monitorFormulaAndFunctionDataQualityQueryDefinition.measure) + && Objects.equals( + this.monitorOptions, monitorFormulaAndFunctionDataQualityQueryDefinition.monitorOptions) + && Objects.equals(this.name, monitorFormulaAndFunctionDataQualityQueryDefinition.name) + && Objects.equals( + this.schemaVersion, monitorFormulaAndFunctionDataQualityQueryDefinition.schemaVersion) + && Objects.equals(this.scope, monitorFormulaAndFunctionDataQualityQueryDefinition.scope) + && Objects.equals( + this.additionalProperties, + monitorFormulaAndFunctionDataQualityQueryDefinition.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + dataSource, + filter, + groupBy, + measure, + monitorOptions, + name, + schemaVersion, + scope, + additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionDataQualityQueryDefinition {\n"); + sb.append(" dataSource: ").append(toIndentedString(dataSource)).append("\n"); + sb.append(" filter: ").append(toIndentedString(filter)).append("\n"); + sb.append(" groupBy: ").append(toIndentedString(groupBy)).append("\n"); + sb.append(" measure: ").append(toIndentedString(measure)).append("\n"); + sb.append(" monitorOptions: ").append(toIndentedString(monitorOptions)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).append("\n"); + sb.append(" schemaVersion: ").append(toIndentedString(schemaVersion)).append("\n"); + sb.append(" scope: ").append(toIndentedString(scope)).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/v1/model/MonitorFormulaAndFunctionQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionQueryDefinition.java index 970893d5945..4a0947e341b 100644 --- a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionQueryDefinition.java +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionQueryDefinition.java @@ -194,6 +194,61 @@ public MonitorFormulaAndFunctionQueryDefinition deserialize( e); } + // deserialize MonitorFormulaAndFunctionDataQualityQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionDataQualityQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionDataQualityQueryDefinition.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 (!((MonitorFormulaAndFunctionDataQualityQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionDataQualityQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'MonitorFormulaAndFunctionDataQualityQueryDefinition'", + e); + } + MonitorFormulaAndFunctionQueryDefinition ret = new MonitorFormulaAndFunctionQueryDefinition(); if (match == 1) { ret.setActualInstance(deserialized); @@ -234,6 +289,12 @@ public MonitorFormulaAndFunctionQueryDefinition(MonitorFormulaAndFunctionCostQue setActualInstance(o); } + public MonitorFormulaAndFunctionQueryDefinition( + MonitorFormulaAndFunctionDataQualityQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + static { schemas.put( "MonitorFormulaAndFunctionEventQueryDefinition", @@ -241,6 +302,9 @@ public MonitorFormulaAndFunctionQueryDefinition(MonitorFormulaAndFunctionCostQue schemas.put( "MonitorFormulaAndFunctionCostQueryDefinition", new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionDataQualityQueryDefinition", + new GenericType() {}); JSON.registerDescendants( MonitorFormulaAndFunctionQueryDefinition.class, Collections.unmodifiableMap(schemas)); } @@ -253,7 +317,8 @@ public Map getSchemas() { /** * Set the instance that matches the oneOf child schema, check the instance parameter is valid * against the oneOf child schemas: MonitorFormulaAndFunctionEventQueryDefinition, - * MonitorFormulaAndFunctionCostQueryDefinition + * MonitorFormulaAndFunctionCostQueryDefinition, + * MonitorFormulaAndFunctionDataQualityQueryDefinition * *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a * composed schema (allOf, anyOf, oneOf). @@ -270,6 +335,13 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionDataQualityQueryDefinition.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -277,15 +349,18 @@ public void setActualInstance(Object instance) { } throw new RuntimeException( "Invalid instance type. Must be MonitorFormulaAndFunctionEventQueryDefinition," - + " MonitorFormulaAndFunctionCostQueryDefinition"); + + " MonitorFormulaAndFunctionCostQueryDefinition," + + " MonitorFormulaAndFunctionDataQualityQueryDefinition"); } /** * Get the actual instance, which can be the following: - * MonitorFormulaAndFunctionEventQueryDefinition, MonitorFormulaAndFunctionCostQueryDefinition + * MonitorFormulaAndFunctionEventQueryDefinition, MonitorFormulaAndFunctionCostQueryDefinition, + * MonitorFormulaAndFunctionDataQualityQueryDefinition * * @return The actual instance (MonitorFormulaAndFunctionEventQueryDefinition, - * MonitorFormulaAndFunctionCostQueryDefinition) + * MonitorFormulaAndFunctionCostQueryDefinition, + * MonitorFormulaAndFunctionDataQualityQueryDefinition) */ @Override public Object getActualInstance() { @@ -319,4 +394,18 @@ public Object getActualInstance() { getMonitorFormulaAndFunctionCostQueryDefinition() throws ClassCastException { return (MonitorFormulaAndFunctionCostQueryDefinition) super.getActualInstance(); } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionDataQualityQueryDefinition`. If the actual + * instance is not `MonitorFormulaAndFunctionDataQualityQueryDefinition`, the ClassCastException + * will be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionDataQualityQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionDataQualityQueryDefinition` + */ + public MonitorFormulaAndFunctionDataQualityQueryDefinition + getMonitorFormulaAndFunctionDataQualityQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionDataQualityQueryDefinition) super.getActualInstance(); + } } diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorType.java b/src/main/java/com/datadog/api/client/v1/model/MonitorType.java index 2755a56fee7..53fece59b34 100644 --- a/src/main/java/com/datadog/api/client/v1/model/MonitorType.java +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorType.java @@ -46,7 +46,8 @@ public class MonitorType extends ModelEnum { "error-tracking alert", "database-monitoring alert", "network-performance alert", - "cost alert")); + "cost alert", + "data-quality alert")); public static final MonitorType COMPOSITE = new MonitorType("composite"); public static final MonitorType EVENT_ALERT = new MonitorType("event alert"); @@ -69,6 +70,7 @@ public class MonitorType extends ModelEnum { public static final MonitorType NETWORK_PERFORMANCE_ALERT = new MonitorType("network-performance alert"); public static final MonitorType COST_ALERT = new MonitorType("cost alert"); + public static final MonitorType DATA_QUALITY_ALERT = new MonitorType("data-quality alert"); MonitorType(String value) { super(value, allowedValues); diff --git a/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.freeze b/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.freeze new file mode 100644 index 00000000000..46cc74fab73 --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.freeze @@ -0,0 +1 @@ +2026-01-12T17:23:49.629Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.json b/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.json new file mode 100644 index 00000000000..5e410a7bde0 --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_Data_Quality_monitor_returns_OK_response.json @@ -0,0 +1,58 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"message\": \"Data quality alert triggered\", \"name\": \"Test-Create_a_Data_Quality_monitor_returns_OK_response-1768238629\", \"options\": {\"thresholds\": {\"critical\": 100}, \"variables\": [{\"data_source\": \"data_quality_metrics\", \"filter\": \"search for column where `database:production AND table:users`\", \"group_by\": [\"entity_id\"], \"measure\": \"row_count\", \"name\": \"query1\"}]}, \"priority\": 3, \"query\": \"formula(\\\"query1\\\").last(\\\"5m\\\") > 100\", \"tags\": [\"test:testcreateadataqualitymonitorreturnsokresponse1768238629\", \"env:ci\"], \"type\": \"data-quality alert\"}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v1/monitor", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"id\":250323411,\"org_id\":321813,\"type\":\"data-quality alert\",\"name\":\"Test-Create_a_Data_Quality_monitor_returns_OK_response-1768238629\",\"message\":\"Data quality alert triggered\",\"tags\":[\"test:testcreateadataqualitymonitorreturnsokresponse1768238629\",\"env:ci\"],\"query\":\"formula(\\\"query1\\\").last(\\\"5m\\\") > 100\",\"options\":{\"thresholds\":{\"critical\":100.0},\"variables\":[{\"data_source\":\"data_quality_metrics\",\"filter\":\"search for column where `database:production AND table:users`\",\"group_by\":[\"entity_id\"],\"measure\":\"row_count\",\"name\":\"query1\"}],\"notify_no_data\":false,\"notify_audit\":false,\"new_host_delay\":300,\"include_tags\":true,\"silenced\":{}},\"multi\":false,\"created_at\":1768238629000,\"created\":\"2026-01-12T17:23:49.782143+00:00\",\"modified\":\"2026-01-12T17:23:49.782143+00:00\",\"deleted\":null,\"priority\":3,\"restricted_roles\":null,\"restriction_policy\":null,\"draft_status\":\"published\",\"assets\":[],\"overall_state_modified\":null,\"overall_state\":\"No Data\",\"creator\":{\"name\":\"CI Account\",\"handle\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"email\":\"team-intg-tools-libs-spam@datadoghq.com\",\"id\":2320499}}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "09dbbe87-ffa4-80b0-59d2-f4f4bb6a2d62" + }, + { + "httpRequest": { + "headers": {}, + "method": "DELETE", + "path": "/api/v1/monitor/250323411", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"deleted_monitor_id\":250323411}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "8aa5bcb8-a168-1f4e-66bc-94bc158d0c77" + } +] \ No newline at end of file diff --git a/src/test/resources/com/datadog/api/client/v1/api/monitors.feature b/src/test/resources/com/datadog/api/client/v1/api/monitors.feature index 75a681927b9..af8d4522e9b 100644 --- a/src/test/resources/com/datadog/api/client/v1/api/monitors.feature +++ b/src/test/resources/com/datadog/api/client/v1/api/monitors.feature @@ -42,6 +42,15 @@ Feature: Monitors When the request is sent Then the response status is 200 OK + @team:DataDog/monitor-app + Scenario: Create a Data Quality monitor returns "OK" response + Given new "CreateMonitor" request + And body with value {"name": "{{ unique }}", "type": "data-quality alert", "query": "formula(\"query1\").last(\"5m\") > 100", "message": "Data quality alert triggered", "tags": ["test:{{ unique_lower_alnum }}", "env:ci"], "priority": 3, "options": {"thresholds": {"critical": 100}, "variables": [{"name": "query1", "data_source": "data_quality_metrics", "measure": "row_count", "filter": "search for column where `database:production AND table:users`", "group_by": ["entity_id"]}]}} + When the request is sent + Then the response status is 200 OK + And the response "name" is equal to "{{ unique }}" + And the response "type" is equal to "data-quality alert" + @team:DataDog/monitor-app Scenario: Create a RUM formula and functions monitor returns "OK" response Given new "CreateMonitor" request