From 065f44608cd6b9debb97b379dbb3c3ddc0de78ad Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Wed, 2 Sep 2026 19:22:03 +0000 Subject: [PATCH] Regenerate client from commit 914e068 of spec repo --- .generator/schemas/v1/openapi.yaml | 133 +++++++ .../v1/monitors/CreateMonitor_1553931399.java | 77 +++++ .../v1/monitors/CreateMonitor_2986418353.java | 79 +++++ ...ulaAndFunctionDataQualityDiffFunction.java | 65 ++++ ...FormulaAndFunctionDataQualityDiffType.java | 69 ++++ ...FunctionDataQualityEntityMetricConfig.java | 281 +++++++++++++++ ...unctionDataQualityModelBoundsOverride.java | 69 ++++ ...FunctionDataQualityModelConfiguration.java | 324 ++++++++++++++++++ ...aAndFunctionDataQualityMonitorOptions.java | 77 ++++- ...nctionDataQualitySourceToTargetConfig.java | 267 +++++++++++++++ .../api/client/v1/api/monitors.feature | 24 ++ .../test-runner-data/manifest.json | 14 + ...del-configuration-returns-ok-response.json | 62 ++++ ...get-configuration-returns-ok-response.json | 66 ++++ .../test-server-data/v1/monitors.json | 184 ++++++++++ 15 files changed, 1790 insertions(+), 1 deletion(-) create mode 100644 examples/v1/monitors/CreateMonitor_1553931399.java create mode 100644 examples/v1/monitors/CreateMonitor_2986418353.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffFunction.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffType.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityEntityMetricConfig.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelBoundsOverride.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelConfiguration.java create mode 100644 src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.java create mode 100644 src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-model-configuration-returns-ok-response.json create mode 100644 src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-source-to-target-configuration-returns-ok-response.json diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index 7056d83d64b..4c51085e74e 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -8997,6 +8997,61 @@ components: type: string x-enum-varnames: - DATA_QUALITY_METRICS + MonitorFormulaAndFunctionDataQualityDiffFunction: + description: |- + Function applied to the measure before it is compared against the predicted bounds. + enum: + - DIFF + - DIFF_PERCENT + example: "DIFF" + type: string + x-enum-varnames: + - DIFF + - DIFF_PERCENT + MonitorFormulaAndFunctionDataQualityDiffType: + description: |- + How the difference between the source and target measures is computed. + `absolute` subtracts the two values, `diff_percent` expresses the difference + as a percentage of the source value. + enum: + - absolute + - diff_percent + example: "absolute" + type: string + x-enum-varnames: + - ABSOLUTE + - DIFF_PERCENT + MonitorFormulaAndFunctionDataQualityEntityMetricConfig: + description: |- + Measure configuration for one side of a source to target comparison. + properties: + custom_sql: + description: Custom SQL query used to compute the measure for this entity. + example: "SELECT COUNT(*) FROM users AS dd_value" + type: string + custom_where: + description: Custom WHERE clause applied when computing the measure for this entity. + example: "USER_ID = 123" + type: string + entity_id: + description: Identifier of the data entity to measure. + example: "01234567-89ab-cdef-0123-456789abcdef" + type: string + entity_type: + description: Type of the data entity to measure. + example: "table" + type: string + group_by_columns: + description: Columns to group results by when computing the measure for this entity. + example: ["col1", "col2"] + items: + description: A column name to group results by. + type: string + type: array + required: + - entity_id + - entity_type + type: object MonitorFormulaAndFunctionDataQualityMeasure: description: |- The data quality measure to query. Common values include: @@ -9005,6 +9060,59 @@ components: `sum`, `uniqueness`. Additional values may be supported. example: "row_count" type: string + MonitorFormulaAndFunctionDataQualityModelBoundsOverride: + description: |- + Restricts which predicted bound the monitor alerts on. `UPPER_ONLY` alerts only when + the measure rises above the upper bound, `LOWER_ONLY` only when it falls below the + lower bound. When unset, the monitor alerts on both. + enum: + - UPPER_ONLY + - LOWER_ONLY + example: "UPPER_ONLY" + type: string + x-enum-varnames: + - UPPER_ONLY + - LOWER_ONLY + MonitorFormulaAndFunctionDataQualityModelConfiguration: + description: |- + Tuning options for the anomaly detection model used by the monitor. + properties: + auto_resolve_days: + description: |- + Number of days after which an open alert is automatically resolved. + When unset, alerts stay open until the measure returns within bounds. + example: 7 + format: int32 + maximum: 365 + minimum: 1 + type: integer + enable_flatline_detection: + description: |- + Whether to alert when the measure stops changing entirely. + Defaults to `true`. + example: true + type: boolean + function: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityDiffFunction" + min_lower_bound_size: + description: |- + Minimum distance between the predicted value and the lower bound. Widening the + lower bound to at least this size suppresses alerts on small downward deviations. + When unset, no minimum is enforced. + example: 10.0 + format: double + type: number + min_upper_bound_size: + description: |- + Minimum distance between the predicted value and the upper bound. Widening the + upper bound to at least this size suppresses alerts on small upward deviations. + When unset, no minimum is enforced. + example: 10.0 + format: double + type: number + model_bounds_override: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityModelBoundsOverride" + type: object MonitorFormulaAndFunctionDataQualityModelTypeOverride: description: Override for the model type used in anomaly detection. enum: @@ -9038,6 +9146,8 @@ components: description: A column name to group results by. type: string type: array + model_configuration: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityModelConfiguration" model_type_override: $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityModelTypeOverride" sensitivity: @@ -9048,6 +9158,8 @@ components: example: 3.0 format: double type: number + source_to_target_config: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualitySourceToTargetConfig" type: object MonitorFormulaAndFunctionDataQualityQueryDefinition: description: A formula and functions data quality query. @@ -9090,6 +9202,27 @@ components: - measure - filter type: object + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig: + description: |- + Configuration for a source to target monitor, which compares the same measure + across two data entities and alerts on the difference between them. + properties: + diff_type: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityDiffType" + entity_type: + description: Type of the data entities being compared. + example: "table" + type: string + source: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityEntityMetricConfig" + target: + $ref: "#/components/schemas/MonitorFormulaAndFunctionDataQualityEntityMetricConfig" + required: + - source + - target + - diff_type + - entity_type + type: object MonitorFormulaAndFunctionEventAggregation: description: Aggregation methods for event platform queries. enum: diff --git a/examples/v1/monitors/CreateMonitor_1553931399.java b/examples/v1/monitors/CreateMonitor_1553931399.java new file mode 100644 index 00000000000..b9006cd287f --- /dev/null +++ b/examples/v1/monitors/CreateMonitor_1553931399.java @@ -0,0 +1,77 @@ +// Create a Data Quality monitor with a model configuration 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.MonitorFormulaAndFunctionDataQualityDiffFunction; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityModelBoundsOverride; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityModelConfiguration; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityMonitorOptions; +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")) + .monitorOptions( + new MonitorFormulaAndFunctionDataQualityMonitorOptions() + .modelConfiguration( + new MonitorFormulaAndFunctionDataQualityModelConfiguration() + .autoResolveDays(7) + .enableFlatlineDetection(true) + .function( + MonitorFormulaAndFunctionDataQualityDiffFunction + .DIFF) + .minLowerBoundSize(10.0) + .minUpperBoundSize(10.0) + .modelBoundsOverride( + MonitorFormulaAndFunctionDataQualityModelBoundsOverride + .UPPER_ONLY))))))); + + 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/examples/v1/monitors/CreateMonitor_2986418353.java b/examples/v1/monitors/CreateMonitor_2986418353.java new file mode 100644 index 00000000000..5e0eb23b9d0 --- /dev/null +++ b/examples/v1/monitors/CreateMonitor_2986418353.java @@ -0,0 +1,79 @@ +// Create a Data Quality monitor with a source to target configuration 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.MonitorFormulaAndFunctionDataQualityDiffType; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityEntityMetricConfig; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityMonitorOptions; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualityQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionDataQualitySourceToTargetConfig; +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")) + .monitorOptions( + new MonitorFormulaAndFunctionDataQualityMonitorOptions() + .sourceToTargetConfig( + new MonitorFormulaAndFunctionDataQualitySourceToTargetConfig() + .source( + new MonitorFormulaAndFunctionDataQualityEntityMetricConfig() + .entityId("source-entity-id") + .entityType("table")) + .target( + new MonitorFormulaAndFunctionDataQualityEntityMetricConfig() + .entityId("target-entity-id") + .entityType("table")) + .diffType( + MonitorFormulaAndFunctionDataQualityDiffType + .ABSOLUTE) + .entityType("table"))))))); + + 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/MonitorFormulaAndFunctionDataQualityDiffFunction.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffFunction.java new file mode 100644 index 00000000000..c6750a21b48 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffFunction.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.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; + +/** Function applied to the measure before it is compared against the predicted bounds. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionDataQualityDiffFunction + .MonitorFormulaAndFunctionDataQualityDiffFunctionSerializer.class) +public class MonitorFormulaAndFunctionDataQualityDiffFunction extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("DIFF", "DIFF_PERCENT")); + + public static final MonitorFormulaAndFunctionDataQualityDiffFunction DIFF = + new MonitorFormulaAndFunctionDataQualityDiffFunction("DIFF"); + public static final MonitorFormulaAndFunctionDataQualityDiffFunction DIFF_PERCENT = + new MonitorFormulaAndFunctionDataQualityDiffFunction("DIFF_PERCENT"); + + MonitorFormulaAndFunctionDataQualityDiffFunction(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionDataQualityDiffFunctionSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionDataQualityDiffFunctionSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionDataQualityDiffFunctionSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionDataQualityDiffFunction value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionDataQualityDiffFunction fromValue(String value) { + return new MonitorFormulaAndFunctionDataQualityDiffFunction(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffType.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffType.java new file mode 100644 index 00000000000..e0f27fd8fb1 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityDiffType.java @@ -0,0 +1,69 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.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; + +/** + * How the difference between the source and target measures is computed. absolute + * subtracts the two values, diff_percent expresses the difference as a percentage of + * the source value. + */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionDataQualityDiffType + .MonitorFormulaAndFunctionDataQualityDiffTypeSerializer.class) +public class MonitorFormulaAndFunctionDataQualityDiffType extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("absolute", "diff_percent")); + + public static final MonitorFormulaAndFunctionDataQualityDiffType ABSOLUTE = + new MonitorFormulaAndFunctionDataQualityDiffType("absolute"); + public static final MonitorFormulaAndFunctionDataQualityDiffType DIFF_PERCENT = + new MonitorFormulaAndFunctionDataQualityDiffType("diff_percent"); + + MonitorFormulaAndFunctionDataQualityDiffType(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionDataQualityDiffTypeSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionDataQualityDiffTypeSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionDataQualityDiffTypeSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionDataQualityDiffType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionDataQualityDiffType fromValue(String value) { + return new MonitorFormulaAndFunctionDataQualityDiffType(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityEntityMetricConfig.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityEntityMetricConfig.java new file mode 100644 index 00000000000..95336b36c7f --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityEntityMetricConfig.java @@ -0,0 +1,281 @@ +/* + * 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; + +/** Measure configuration for one side of a source to target comparison. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionDataQualityEntityMetricConfig.JSON_PROPERTY_CUSTOM_SQL, + MonitorFormulaAndFunctionDataQualityEntityMetricConfig.JSON_PROPERTY_CUSTOM_WHERE, + MonitorFormulaAndFunctionDataQualityEntityMetricConfig.JSON_PROPERTY_ENTITY_ID, + MonitorFormulaAndFunctionDataQualityEntityMetricConfig.JSON_PROPERTY_ENTITY_TYPE, + MonitorFormulaAndFunctionDataQualityEntityMetricConfig.JSON_PROPERTY_GROUP_BY_COLUMNS +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionDataQualityEntityMetricConfig { + @JsonIgnore public boolean unparsed = false; + 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_ENTITY_ID = "entity_id"; + private String entityId; + + public static final String JSON_PROPERTY_ENTITY_TYPE = "entity_type"; + private String entityType; + + public static final String JSON_PROPERTY_GROUP_BY_COLUMNS = "group_by_columns"; + private List groupByColumns = null; + + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig() {} + + @JsonCreator + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig( + @JsonProperty(required = true, value = JSON_PROPERTY_ENTITY_ID) String entityId, + @JsonProperty(required = true, value = JSON_PROPERTY_ENTITY_TYPE) String entityType) { + this.entityId = entityId; + this.entityType = entityType; + } + + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig customSql(String customSql) { + this.customSql = customSql; + return this; + } + + /** + * Custom SQL query used to compute the measure for this entity. + * + * @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 MonitorFormulaAndFunctionDataQualityEntityMetricConfig customWhere(String customWhere) { + this.customWhere = customWhere; + return this; + } + + /** + * Custom WHERE clause applied when computing the measure for this entity. + * + * @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 MonitorFormulaAndFunctionDataQualityEntityMetricConfig entityId(String entityId) { + this.entityId = entityId; + return this; + } + + /** + * Identifier of the data entity to measure. + * + * @return entityId + */ + @JsonProperty(JSON_PROPERTY_ENTITY_ID) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getEntityId() { + return entityId; + } + + public void setEntityId(String entityId) { + this.entityId = entityId; + } + + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig entityType(String entityType) { + this.entityType = entityType; + return this; + } + + /** + * Type of the data entity to measure. + * + * @return entityType + */ + @JsonProperty(JSON_PROPERTY_ENTITY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getEntityType() { + return entityType; + } + + public void setEntityType(String entityType) { + this.entityType = entityType; + } + + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig groupByColumns( + List groupByColumns) { + this.groupByColumns = groupByColumns; + return this; + } + + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig addGroupByColumnsItem( + String groupByColumnsItem) { + if (this.groupByColumns == null) { + this.groupByColumns = new ArrayList<>(); + } + this.groupByColumns.add(groupByColumnsItem); + return this; + } + + /** + * Columns to group results by when computing the measure for this entity. + * + * @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; + } + + /** + * 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 MonitorFormulaAndFunctionDataQualityEntityMetricConfig + */ + @JsonAnySetter + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig 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 MonitorFormulaAndFunctionDataQualityEntityMetricConfig object is equal to + * o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionDataQualityEntityMetricConfig + monitorFormulaAndFunctionDataQualityEntityMetricConfig = + (MonitorFormulaAndFunctionDataQualityEntityMetricConfig) o; + return Objects.equals( + this.customSql, monitorFormulaAndFunctionDataQualityEntityMetricConfig.customSql) + && Objects.equals( + this.customWhere, monitorFormulaAndFunctionDataQualityEntityMetricConfig.customWhere) + && Objects.equals( + this.entityId, monitorFormulaAndFunctionDataQualityEntityMetricConfig.entityId) + && Objects.equals( + this.entityType, monitorFormulaAndFunctionDataQualityEntityMetricConfig.entityType) + && Objects.equals( + this.groupByColumns, + monitorFormulaAndFunctionDataQualityEntityMetricConfig.groupByColumns) + && Objects.equals( + this.additionalProperties, + monitorFormulaAndFunctionDataQualityEntityMetricConfig.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + customSql, customWhere, entityId, entityType, groupByColumns, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionDataQualityEntityMetricConfig {\n"); + sb.append(" customSql: ").append(toIndentedString(customSql)).append("\n"); + sb.append(" customWhere: ").append(toIndentedString(customWhere)).append("\n"); + sb.append(" entityId: ").append(toIndentedString(entityId)).append("\n"); + sb.append(" entityType: ").append(toIndentedString(entityType)).append("\n"); + sb.append(" groupByColumns: ").append(toIndentedString(groupByColumns)).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/MonitorFormulaAndFunctionDataQualityModelBoundsOverride.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelBoundsOverride.java new file mode 100644 index 00000000000..08f0dee495e --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelBoundsOverride.java @@ -0,0 +1,69 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.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; + +/** + * Restricts which predicted bound the monitor alerts on. UPPER_ONLY alerts only when + * the measure rises above the upper bound, LOWER_ONLY only when it falls below the + * lower bound. When unset, the monitor alerts on both. + */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionDataQualityModelBoundsOverride + .MonitorFormulaAndFunctionDataQualityModelBoundsOverrideSerializer.class) +public class MonitorFormulaAndFunctionDataQualityModelBoundsOverride extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("UPPER_ONLY", "LOWER_ONLY")); + + public static final MonitorFormulaAndFunctionDataQualityModelBoundsOverride UPPER_ONLY = + new MonitorFormulaAndFunctionDataQualityModelBoundsOverride("UPPER_ONLY"); + public static final MonitorFormulaAndFunctionDataQualityModelBoundsOverride LOWER_ONLY = + new MonitorFormulaAndFunctionDataQualityModelBoundsOverride("LOWER_ONLY"); + + MonitorFormulaAndFunctionDataQualityModelBoundsOverride(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionDataQualityModelBoundsOverrideSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionDataQualityModelBoundsOverrideSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionDataQualityModelBoundsOverrideSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionDataQualityModelBoundsOverride value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionDataQualityModelBoundsOverride fromValue(String value) { + return new MonitorFormulaAndFunctionDataQualityModelBoundsOverride(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelConfiguration.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelConfiguration.java new file mode 100644 index 00000000000..4f7948184a2 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityModelConfiguration.java @@ -0,0 +1,324 @@ +/* + * 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.HashMap; +import java.util.Map; +import java.util.Objects; + +/** Tuning options for the anomaly detection model used by the monitor. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_AUTO_RESOLVE_DAYS, + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_ENABLE_FLATLINE_DETECTION, + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_FUNCTION, + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_MIN_LOWER_BOUND_SIZE, + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_MIN_UPPER_BOUND_SIZE, + MonitorFormulaAndFunctionDataQualityModelConfiguration.JSON_PROPERTY_MODEL_BOUNDS_OVERRIDE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionDataQualityModelConfiguration { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_AUTO_RESOLVE_DAYS = "auto_resolve_days"; + private Integer autoResolveDays; + + public static final String JSON_PROPERTY_ENABLE_FLATLINE_DETECTION = "enable_flatline_detection"; + private Boolean enableFlatlineDetection; + + public static final String JSON_PROPERTY_FUNCTION = "function"; + private MonitorFormulaAndFunctionDataQualityDiffFunction function; + + public static final String JSON_PROPERTY_MIN_LOWER_BOUND_SIZE = "min_lower_bound_size"; + private Double minLowerBoundSize; + + public static final String JSON_PROPERTY_MIN_UPPER_BOUND_SIZE = "min_upper_bound_size"; + private Double minUpperBoundSize; + + public static final String JSON_PROPERTY_MODEL_BOUNDS_OVERRIDE = "model_bounds_override"; + private MonitorFormulaAndFunctionDataQualityModelBoundsOverride modelBoundsOverride; + + public MonitorFormulaAndFunctionDataQualityModelConfiguration autoResolveDays( + Integer autoResolveDays) { + this.autoResolveDays = autoResolveDays; + return this; + } + + /** + * Number of days after which an open alert is automatically resolved. When unset, alerts stay + * open until the measure returns within bounds. minimum: 1 maximum: 365 + * + * @return autoResolveDays + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_AUTO_RESOLVE_DAYS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Integer getAutoResolveDays() { + return autoResolveDays; + } + + public void setAutoResolveDays(Integer autoResolveDays) { + this.autoResolveDays = autoResolveDays; + } + + public MonitorFormulaAndFunctionDataQualityModelConfiguration enableFlatlineDetection( + Boolean enableFlatlineDetection) { + this.enableFlatlineDetection = enableFlatlineDetection; + return this; + } + + /** + * Whether to alert when the measure stops changing entirely. Defaults to true. + * + * @return enableFlatlineDetection + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ENABLE_FLATLINE_DETECTION) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Boolean getEnableFlatlineDetection() { + return enableFlatlineDetection; + } + + public void setEnableFlatlineDetection(Boolean enableFlatlineDetection) { + this.enableFlatlineDetection = enableFlatlineDetection; + } + + public MonitorFormulaAndFunctionDataQualityModelConfiguration function( + MonitorFormulaAndFunctionDataQualityDiffFunction function) { + this.function = function; + this.unparsed |= !function.isValid(); + return this; + } + + /** + * Function applied to the measure before it is compared against the predicted bounds. + * + * @return function + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_FUNCTION) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualityDiffFunction getFunction() { + return function; + } + + public void setFunction(MonitorFormulaAndFunctionDataQualityDiffFunction function) { + if (!function.isValid()) { + this.unparsed = true; + } + this.function = function; + } + + public MonitorFormulaAndFunctionDataQualityModelConfiguration minLowerBoundSize( + Double minLowerBoundSize) { + this.minLowerBoundSize = minLowerBoundSize; + return this; + } + + /** + * Minimum distance between the predicted value and the lower bound. Widening the lower bound to + * at least this size suppresses alerts on small downward deviations. When unset, no minimum is + * enforced. + * + * @return minLowerBoundSize + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MIN_LOWER_BOUND_SIZE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Double getMinLowerBoundSize() { + return minLowerBoundSize; + } + + public void setMinLowerBoundSize(Double minLowerBoundSize) { + this.minLowerBoundSize = minLowerBoundSize; + } + + public MonitorFormulaAndFunctionDataQualityModelConfiguration minUpperBoundSize( + Double minUpperBoundSize) { + this.minUpperBoundSize = minUpperBoundSize; + return this; + } + + /** + * Minimum distance between the predicted value and the upper bound. Widening the upper bound to + * at least this size suppresses alerts on small upward deviations. When unset, no minimum is + * enforced. + * + * @return minUpperBoundSize + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MIN_UPPER_BOUND_SIZE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Double getMinUpperBoundSize() { + return minUpperBoundSize; + } + + public void setMinUpperBoundSize(Double minUpperBoundSize) { + this.minUpperBoundSize = minUpperBoundSize; + } + + public MonitorFormulaAndFunctionDataQualityModelConfiguration modelBoundsOverride( + MonitorFormulaAndFunctionDataQualityModelBoundsOverride modelBoundsOverride) { + this.modelBoundsOverride = modelBoundsOverride; + this.unparsed |= !modelBoundsOverride.isValid(); + return this; + } + + /** + * Restricts which predicted bound the monitor alerts on. UPPER_ONLY alerts only when + * the measure rises above the upper bound, LOWER_ONLY only when it falls below the + * lower bound. When unset, the monitor alerts on both. + * + * @return modelBoundsOverride + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MODEL_BOUNDS_OVERRIDE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualityModelBoundsOverride getModelBoundsOverride() { + return modelBoundsOverride; + } + + public void setModelBoundsOverride( + MonitorFormulaAndFunctionDataQualityModelBoundsOverride modelBoundsOverride) { + if (!modelBoundsOverride.isValid()) { + this.unparsed = true; + } + this.modelBoundsOverride = modelBoundsOverride; + } + + /** + * 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 MonitorFormulaAndFunctionDataQualityModelConfiguration + */ + @JsonAnySetter + public MonitorFormulaAndFunctionDataQualityModelConfiguration 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 MonitorFormulaAndFunctionDataQualityModelConfiguration object is equal to + * o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionDataQualityModelConfiguration + monitorFormulaAndFunctionDataQualityModelConfiguration = + (MonitorFormulaAndFunctionDataQualityModelConfiguration) o; + return Objects.equals( + this.autoResolveDays, + monitorFormulaAndFunctionDataQualityModelConfiguration.autoResolveDays) + && Objects.equals( + this.enableFlatlineDetection, + monitorFormulaAndFunctionDataQualityModelConfiguration.enableFlatlineDetection) + && Objects.equals( + this.function, monitorFormulaAndFunctionDataQualityModelConfiguration.function) + && Objects.equals( + this.minLowerBoundSize, + monitorFormulaAndFunctionDataQualityModelConfiguration.minLowerBoundSize) + && Objects.equals( + this.minUpperBoundSize, + monitorFormulaAndFunctionDataQualityModelConfiguration.minUpperBoundSize) + && Objects.equals( + this.modelBoundsOverride, + monitorFormulaAndFunctionDataQualityModelConfiguration.modelBoundsOverride) + && Objects.equals( + this.additionalProperties, + monitorFormulaAndFunctionDataQualityModelConfiguration.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash( + autoResolveDays, + enableFlatlineDetection, + function, + minLowerBoundSize, + minUpperBoundSize, + modelBoundsOverride, + additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionDataQualityModelConfiguration {\n"); + sb.append(" autoResolveDays: ").append(toIndentedString(autoResolveDays)).append("\n"); + sb.append(" enableFlatlineDetection: ") + .append(toIndentedString(enableFlatlineDetection)) + .append("\n"); + sb.append(" function: ").append(toIndentedString(function)).append("\n"); + sb.append(" minLowerBoundSize: ").append(toIndentedString(minLowerBoundSize)).append("\n"); + sb.append(" minUpperBoundSize: ").append(toIndentedString(minUpperBoundSize)).append("\n"); + sb.append(" modelBoundsOverride: ") + .append(toIndentedString(modelBoundsOverride)) + .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/MonitorFormulaAndFunctionDataQualityMonitorOptions.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java index a6df9208c32..637c58e18d6 100644 --- a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualityMonitorOptions.java @@ -24,8 +24,10 @@ MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_CUSTOM_SQL, MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_CUSTOM_WHERE, MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_GROUP_BY_COLUMNS, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_MODEL_CONFIGURATION, MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_MODEL_TYPE_OVERRIDE, - MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_SENSITIVITY + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_SENSITIVITY, + MonitorFormulaAndFunctionDataQualityMonitorOptions.JSON_PROPERTY_SOURCE_TO_TARGET_CONFIG }) @jakarta.annotation.Generated( value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") @@ -43,12 +45,18 @@ public class MonitorFormulaAndFunctionDataQualityMonitorOptions { public static final String JSON_PROPERTY_GROUP_BY_COLUMNS = "group_by_columns"; private List groupByColumns = null; + public static final String JSON_PROPERTY_MODEL_CONFIGURATION = "model_configuration"; + private MonitorFormulaAndFunctionDataQualityModelConfiguration modelConfiguration; + public static final String JSON_PROPERTY_MODEL_TYPE_OVERRIDE = "model_type_override"; private MonitorFormulaAndFunctionDataQualityModelTypeOverride modelTypeOverride; public static final String JSON_PROPERTY_SENSITIVITY = "sensitivity"; private Double sensitivity; + public static final String JSON_PROPERTY_SOURCE_TO_TARGET_CONFIG = "source_to_target_config"; + private MonitorFormulaAndFunctionDataQualitySourceToTargetConfig sourceToTargetConfig; + public MonitorFormulaAndFunctionDataQualityMonitorOptions crontabOverride( String crontabOverride) { this.crontabOverride = crontabOverride; @@ -144,6 +152,33 @@ public void setGroupByColumns(List groupByColumns) { this.groupByColumns = groupByColumns; } + public MonitorFormulaAndFunctionDataQualityMonitorOptions modelConfiguration( + MonitorFormulaAndFunctionDataQualityModelConfiguration modelConfiguration) { + this.modelConfiguration = modelConfiguration; + this.unparsed |= modelConfiguration.unparsed; + return this; + } + + /** + * Tuning options for the anomaly detection model used by the monitor. + * + * @return modelConfiguration + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MODEL_CONFIGURATION) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualityModelConfiguration getModelConfiguration() { + return modelConfiguration; + } + + public void setModelConfiguration( + MonitorFormulaAndFunctionDataQualityModelConfiguration modelConfiguration) { + this.modelConfiguration = modelConfiguration; + if (modelConfiguration != null) { + this.unparsed |= modelConfiguration.unparsed; + } + } + public MonitorFormulaAndFunctionDataQualityMonitorOptions modelTypeOverride( MonitorFormulaAndFunctionDataQualityModelTypeOverride modelTypeOverride) { this.modelTypeOverride = modelTypeOverride; @@ -194,6 +229,34 @@ public void setSensitivity(Double sensitivity) { this.sensitivity = sensitivity; } + public MonitorFormulaAndFunctionDataQualityMonitorOptions sourceToTargetConfig( + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig sourceToTargetConfig) { + this.sourceToTargetConfig = sourceToTargetConfig; + this.unparsed |= sourceToTargetConfig.unparsed; + return this; + } + + /** + * Configuration for a source to target monitor, which compares the same measure across two data + * entities and alerts on the difference between them. + * + * @return sourceToTargetConfig + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_SOURCE_TO_TARGET_CONFIG) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig getSourceToTargetConfig() { + return sourceToTargetConfig; + } + + public void setSourceToTargetConfig( + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig sourceToTargetConfig) { + this.sourceToTargetConfig = sourceToTargetConfig; + if (sourceToTargetConfig != null) { + this.unparsed |= sourceToTargetConfig.unparsed; + } + } + /** * A container for additional, undeclared properties. This is a holder for any undeclared * properties as specified with the 'additionalProperties' keyword in the OAS document. @@ -264,11 +327,17 @@ public boolean equals(Object o) { this.customWhere, monitorFormulaAndFunctionDataQualityMonitorOptions.customWhere) && Objects.equals( this.groupByColumns, monitorFormulaAndFunctionDataQualityMonitorOptions.groupByColumns) + && Objects.equals( + this.modelConfiguration, + monitorFormulaAndFunctionDataQualityMonitorOptions.modelConfiguration) && Objects.equals( this.modelTypeOverride, monitorFormulaAndFunctionDataQualityMonitorOptions.modelTypeOverride) && Objects.equals( this.sensitivity, monitorFormulaAndFunctionDataQualityMonitorOptions.sensitivity) + && Objects.equals( + this.sourceToTargetConfig, + monitorFormulaAndFunctionDataQualityMonitorOptions.sourceToTargetConfig) && Objects.equals( this.additionalProperties, monitorFormulaAndFunctionDataQualityMonitorOptions.additionalProperties); @@ -281,8 +350,10 @@ public int hashCode() { customSql, customWhere, groupByColumns, + modelConfiguration, modelTypeOverride, sensitivity, + sourceToTargetConfig, additionalProperties); } @@ -294,8 +365,12 @@ public String toString() { 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(" modelConfiguration: ").append(toIndentedString(modelConfiguration)).append("\n"); sb.append(" modelTypeOverride: ").append(toIndentedString(modelTypeOverride)).append("\n"); sb.append(" sensitivity: ").append(toIndentedString(sensitivity)).append("\n"); + sb.append(" sourceToTargetConfig: ") + .append(toIndentedString(sourceToTargetConfig)) + .append("\n"); sb.append(" additionalProperties: ") .append(toIndentedString(additionalProperties)) .append("\n"); diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.java new file mode 100644 index 00000000000..33a47ee60a3 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.java @@ -0,0 +1,267 @@ +/* + * 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.HashMap; +import java.util.Map; +import java.util.Objects; + +/** + * Configuration for a source to target monitor, which compares the same measure across two data + * entities and alerts on the difference between them. + */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.JSON_PROPERTY_DIFF_TYPE, + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.JSON_PROPERTY_ENTITY_TYPE, + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.JSON_PROPERTY_SOURCE, + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig.JSON_PROPERTY_TARGET +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionDataQualitySourceToTargetConfig { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_DIFF_TYPE = "diff_type"; + private MonitorFormulaAndFunctionDataQualityDiffType diffType; + + public static final String JSON_PROPERTY_ENTITY_TYPE = "entity_type"; + private String entityType; + + public static final String JSON_PROPERTY_SOURCE = "source"; + private MonitorFormulaAndFunctionDataQualityEntityMetricConfig source; + + public static final String JSON_PROPERTY_TARGET = "target"; + private MonitorFormulaAndFunctionDataQualityEntityMetricConfig target; + + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig() {} + + @JsonCreator + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig( + @JsonProperty(required = true, value = JSON_PROPERTY_DIFF_TYPE) + MonitorFormulaAndFunctionDataQualityDiffType diffType, + @JsonProperty(required = true, value = JSON_PROPERTY_ENTITY_TYPE) String entityType, + @JsonProperty(required = true, value = JSON_PROPERTY_SOURCE) + MonitorFormulaAndFunctionDataQualityEntityMetricConfig source, + @JsonProperty(required = true, value = JSON_PROPERTY_TARGET) + MonitorFormulaAndFunctionDataQualityEntityMetricConfig target) { + this.diffType = diffType; + this.unparsed |= !diffType.isValid(); + this.entityType = entityType; + this.source = source; + this.unparsed |= source.unparsed; + this.target = target; + this.unparsed |= target.unparsed; + } + + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig diffType( + MonitorFormulaAndFunctionDataQualityDiffType diffType) { + this.diffType = diffType; + this.unparsed |= !diffType.isValid(); + return this; + } + + /** + * How the difference between the source and target measures is computed. absolute + * subtracts the two values, diff_percent expresses the difference as a percentage of + * the source value. + * + * @return diffType + */ + @JsonProperty(JSON_PROPERTY_DIFF_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionDataQualityDiffType getDiffType() { + return diffType; + } + + public void setDiffType(MonitorFormulaAndFunctionDataQualityDiffType diffType) { + if (!diffType.isValid()) { + this.unparsed = true; + } + this.diffType = diffType; + } + + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig entityType(String entityType) { + this.entityType = entityType; + return this; + } + + /** + * Type of the data entities being compared. + * + * @return entityType + */ + @JsonProperty(JSON_PROPERTY_ENTITY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getEntityType() { + return entityType; + } + + public void setEntityType(String entityType) { + this.entityType = entityType; + } + + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig source( + MonitorFormulaAndFunctionDataQualityEntityMetricConfig source) { + this.source = source; + this.unparsed |= source.unparsed; + return this; + } + + /** + * Measure configuration for one side of a source to target comparison. + * + * @return source + */ + @JsonProperty(JSON_PROPERTY_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig getSource() { + return source; + } + + public void setSource(MonitorFormulaAndFunctionDataQualityEntityMetricConfig source) { + this.source = source; + if (source != null) { + this.unparsed |= source.unparsed; + } + } + + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig target( + MonitorFormulaAndFunctionDataQualityEntityMetricConfig target) { + this.target = target; + this.unparsed |= target.unparsed; + return this; + } + + /** + * Measure configuration for one side of a source to target comparison. + * + * @return target + */ + @JsonProperty(JSON_PROPERTY_TARGET) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionDataQualityEntityMetricConfig getTarget() { + return target; + } + + public void setTarget(MonitorFormulaAndFunctionDataQualityEntityMetricConfig target) { + this.target = target; + if (target != null) { + this.unparsed |= target.unparsed; + } + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return MonitorFormulaAndFunctionDataQualitySourceToTargetConfig + */ + @JsonAnySetter + public MonitorFormulaAndFunctionDataQualitySourceToTargetConfig 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 MonitorFormulaAndFunctionDataQualitySourceToTargetConfig object is equal to + * o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionDataQualitySourceToTargetConfig + monitorFormulaAndFunctionDataQualitySourceToTargetConfig = + (MonitorFormulaAndFunctionDataQualitySourceToTargetConfig) o; + return Objects.equals( + this.diffType, monitorFormulaAndFunctionDataQualitySourceToTargetConfig.diffType) + && Objects.equals( + this.entityType, monitorFormulaAndFunctionDataQualitySourceToTargetConfig.entityType) + && Objects.equals( + this.source, monitorFormulaAndFunctionDataQualitySourceToTargetConfig.source) + && Objects.equals( + this.target, monitorFormulaAndFunctionDataQualitySourceToTargetConfig.target) + && Objects.equals( + this.additionalProperties, + monitorFormulaAndFunctionDataQualitySourceToTargetConfig.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(diffType, entityType, source, target, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionDataQualitySourceToTargetConfig {\n"); + sb.append(" diffType: ").append(toIndentedString(diffType)).append("\n"); + sb.append(" entityType: ").append(toIndentedString(entityType)).append("\n"); + sb.append(" source: ").append(toIndentedString(source)).append("\n"); + sb.append(" target: ").append(toIndentedString(target)).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/test/resources/com/datadog/api/client/v1/api/monitors.feature b/src/test/resources/com/datadog/api/client/v1/api/monitors.feature index 9fc73243c7b..5b9dffa8b1c 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 @@ -60,6 +60,30 @@ Feature: Monitors 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 Data Quality monitor with a model configuration 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"], "monitor_options": {"model_configuration": {"auto_resolve_days": 7, "enable_flatline_detection": true, "function": "DIFF", "min_lower_bound_size": 10.0, "min_upper_bound_size": 10.0, "model_bounds_override": "UPPER_ONLY"}}}]}} + 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" + And the response "options.variables[0].monitor_options.model_configuration.auto_resolve_days" is equal to 7 + And the response "options.variables[0].monitor_options.model_configuration.function" is equal to "DIFF" + And the response "options.variables[0].monitor_options.model_configuration.model_bounds_override" is equal to "UPPER_ONLY" + + @team:DataDog/monitor-app + Scenario: Create a Data Quality monitor with a source to target configuration 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"], "monitor_options": {"source_to_target_config": {"source": {"entity_id": "source-entity-id", "entity_type": "table"}, "target": {"entity_id": "target-entity-id", "entity_type": "table"}, "diff_type": "absolute", "entity_type": "table"}}}]}} + 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" + And the response "options.variables[0].monitor_options.source_to_target_config.diff_type" is equal to "absolute" + And the response "options.variables[0].monitor_options.source_to_target_config.source.entity_id" is equal to "source-entity-id" + And the response "options.variables[0].monitor_options.source_to_target_config.target.entity_id" is equal to "target-entity-id" + @team:DataDog/monitor-app Scenario: Create a Data Quality monitor with sensitivity returns "OK" response Given new "CreateMonitor" request diff --git a/src/test/resources/generated-test/test-runner-data/manifest.json b/src/test/resources/generated-test/test-runner-data/manifest.json index 532fe647f8d..084ef46edee 100644 --- a/src/test/resources/generated-test/test-runner-data/manifest.json +++ b/src/test/resources/generated-test/test-runner-data/manifest.json @@ -1379,6 +1379,20 @@ "scenario": "Create a Data Quality monitor returns \"OK\" response", "version": "v1" }, + { + "feature": "Monitors", + "feature_file": "../../com/datadog/api/client/v1/api/monitors.feature", + "file": "v1/monitors/create-a-data-quality-monitor-with-a-model-configuration-returns-ok-response.json", + "scenario": "Create a Data Quality monitor with a model configuration returns \"OK\" response", + "version": "v1" + }, + { + "feature": "Monitors", + "feature_file": "../../com/datadog/api/client/v1/api/monitors.feature", + "file": "v1/monitors/create-a-data-quality-monitor-with-a-source-to-target-configuration-returns-ok-response.json", + "scenario": "Create a Data Quality monitor with a source to target configuration returns \"OK\" response", + "version": "v1" + }, { "feature": "Monitors", "feature_file": "../../com/datadog/api/client/v1/api/monitors.feature", diff --git a/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-model-configuration-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-model-configuration-returns-ok-response.json new file mode 100644 index 00000000000..1cff8218bfe --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-model-configuration-returns-ok-response.json @@ -0,0 +1,62 @@ +{ + "api": "Monitors", + "expected_status": 200, + "feature": "Monitors", + "id": "v1/Monitors/Create a Data Quality monitor with a model configuration returns \"OK\" response", + "operation_id": "CreateMonitor", + "request": { + "body": { + "schema": { + "format": null, + "ref": "Monitor", + "type": "object" + }, + "source": "inline", + "value": { + "message": "Data quality alert triggered", + "name": "{{ unique }}", + "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", + "monitor_options": { + "model_configuration": { + "auto_resolve_days": 7, + "enable_flatline_detection": true, + "function": "DIFF", + "min_lower_bound_size": 10.0, + "min_upper_bound_size": 10.0, + "model_bounds_override": "UPPER_ONLY" + } + }, + "name": "query1" + } + ] + }, + "priority": 3, + "query": "formula(\"query1\").last(\"5m\") > 100", + "tags": [ + "test:{{ unique_lower_alnum }}", + "env:ci" + ], + "type": "data-quality alert" + } + }, + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v1/monitor" + }, + "scenario": "Create a Data Quality monitor with a model configuration returns \"OK\" response", + "schema_version": 1, + "version": "v1" +} diff --git a/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-source-to-target-configuration-returns-ok-response.json b/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-source-to-target-configuration-returns-ok-response.json new file mode 100644 index 00000000000..228d59c4ade --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v1/monitors/create-a-data-quality-monitor-with-a-source-to-target-configuration-returns-ok-response.json @@ -0,0 +1,66 @@ +{ + "api": "Monitors", + "expected_status": 200, + "feature": "Monitors", + "id": "v1/Monitors/Create a Data Quality monitor with a source to target configuration returns \"OK\" response", + "operation_id": "CreateMonitor", + "request": { + "body": { + "schema": { + "format": null, + "ref": "Monitor", + "type": "object" + }, + "source": "inline", + "value": { + "message": "Data quality alert triggered", + "name": "{{ unique }}", + "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", + "monitor_options": { + "source_to_target_config": { + "diff_type": "absolute", + "entity_type": "table", + "source": { + "entity_id": "source-entity-id", + "entity_type": "table" + }, + "target": { + "entity_id": "target-entity-id", + "entity_type": "table" + } + } + }, + "name": "query1" + } + ] + }, + "priority": 3, + "query": "formula(\"query1\").last(\"5m\") > 100", + "tags": [ + "test:{{ unique_lower_alnum }}", + "env:ci" + ], + "type": "data-quality alert" + } + }, + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v1/monitor" + }, + "scenario": "Create a Data Quality monitor with a source to target configuration returns \"OK\" response", + "schema_version": 1, + "version": "v1" +} diff --git a/src/test/resources/generated-test/test-server-data/v1/monitors.json b/src/test/resources/generated-test/test-server-data/v1/monitors.json index 4e5239cc94a..083b2816e45 100644 --- a/src/test/resources/generated-test/test-server-data/v1/monitors.json +++ b/src/test/resources/generated-test/test-server-data/v1/monitors.json @@ -348,6 +348,190 @@ "scenario": "Create a Data Quality monitor returns \"OK\" response", "version": "v1" }, + { + "feature": "Monitors", + "frozen_at": "2026-09-02T15:20:38.256Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": { + "message": "Data quality alert triggered", + "name": "Test-Create_a_Data_Quality_monitor_with_a_model_configuration_returns_OK_response-1788362438", + "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", + "monitor_options": { + "model_configuration": { + "auto_resolve_days": 7, + "enable_flatline_detection": true, + "function": "DIFF", + "min_lower_bound_size": 10, + "min_upper_bound_size": 10, + "model_bounds_override": "UPPER_ONLY" + } + }, + "name": "query1" + } + ] + }, + "priority": 3, + "query": "formula(\"query1\").last(\"5m\") > 100", + "tags": [ + "test:testcreateadataqualitymonitorwithamodelconfigurationreturnsokresponse1788362438", + "env:ci" + ], + "type": "data-quality alert" + } + }, + "content_type": "application/json", + "method": "POST", + "path": "/api/v1/monitor", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"id\":318694962,\"org_id\":321813,\"type\":\"data-quality alert\",\"name\":\"Test-Create_a_Data_Quality_monitor_with_a_model_configuration_returns_OK_response-1788362438\",\"message\":\"Data quality alert triggered\",\"tags\":[\"test:testcreateadataqualitymonitorwithamodelconfigurationreturnsokresponse1788362438\",\"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\",\"monitor_options\":{\"model_configuration\":{\"auto_resolve_days\":7,\"enable_flatline_detection\":true,\"function\":\"DIFF\",\"min_lower_bound_size\":10,\"min_upper_bound_size\":10,\"model_bounds_override\":\"UPPER_ONLY\"}},\"name\":\"query1\"}],\"notify_no_data\":false,\"notify_audit\":false,\"new_host_delay\":300,\"include_tags\":true,\"silenced\":{}},\"multi\":false,\"created_at\":1788362438000,\"created\":\"2026-09-02T15:20:38.449441+00:00\",\"modified\":\"2026-09-02T15:20:38.449441+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" + }, + "reason": "OK", + "status": 200 + } + }, + { + "request": { + "body": { + "type": "empty", + "value": null + }, + "content_type": "", + "method": "DELETE", + "path": "/api/v1/monitor/318694962", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"deleted_monitor_id\":318694962}\n" + }, + "headers": { + "content-type": "application/json" + }, + "reason": "OK", + "status": 200 + } + } + ], + "scenario": "Create a Data Quality monitor with a model configuration returns \"OK\" response", + "version": "v1" + }, + { + "feature": "Monitors", + "frozen_at": "2026-09-02T15:20:38.978Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": { + "message": "Data quality alert triggered", + "name": "Test-Create_a_Data_Quality_monitor_with_a_source_to_target_configuration_returns_OK_response-1788362438", + "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", + "monitor_options": { + "source_to_target_config": { + "diff_type": "absolute", + "entity_type": "table", + "source": { + "entity_id": "source-entity-id", + "entity_type": "table" + }, + "target": { + "entity_id": "target-entity-id", + "entity_type": "table" + } + } + }, + "name": "query1" + } + ] + }, + "priority": 3, + "query": "formula(\"query1\").last(\"5m\") > 100", + "tags": [ + "test:testcreateadataqualitymonitorwithasourcetotargetconfigurationreturnsokresponse1788362438", + "env:ci" + ], + "type": "data-quality alert" + } + }, + "content_type": "application/json", + "method": "POST", + "path": "/api/v1/monitor", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"id\":318694966,\"org_id\":321813,\"type\":\"data-quality alert\",\"name\":\"Test-Create_a_Data_Quality_monitor_with_a_source_to_target_configuration_returns_OK_response-1788362438\",\"message\":\"Data quality alert triggered\",\"tags\":[\"test:testcreateadataqualitymonitorwithasourcetotargetconfigurationreturnsokresponse1788362438\",\"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\",\"monitor_options\":{\"source_to_target_config\":{\"diff_type\":\"absolute\",\"entity_type\":\"table\",\"source\":{\"entity_id\":\"source-entity-id\",\"entity_type\":\"table\"},\"target\":{\"entity_id\":\"target-entity-id\",\"entity_type\":\"table\"}}},\"name\":\"query1\"}],\"notify_no_data\":false,\"notify_audit\":false,\"new_host_delay\":300,\"include_tags\":true,\"silenced\":{}},\"multi\":false,\"created_at\":1788362439000,\"created\":\"2026-09-02T15:20:39.152487+00:00\",\"modified\":\"2026-09-02T15:20:39.152487+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" + }, + "reason": "OK", + "status": 200 + } + }, + { + "request": { + "body": { + "type": "empty", + "value": null + }, + "content_type": "", + "method": "DELETE", + "path": "/api/v1/monitor/318694966", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{\"deleted_monitor_id\":318694966}\n" + }, + "headers": { + "content-type": "application/json" + }, + "reason": "OK", + "status": 200 + } + } + ], + "scenario": "Create a Data Quality monitor with a source to target configuration returns \"OK\" response", + "version": "v1" + }, { "feature": "Monitors", "frozen_at": "2026-07-31T16:36:50.561Z",