diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index 0d4728f9005..0af0eb5f67c 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -7738,6 +7738,161 @@ components: x-enum-varnames: - DRAFT - PUBLISHED + MonitorFormulaAndFunctionAggregateAugmentQuery: + description: Augment query for aggregate augmented queries. Can be an events + query or a reference table query. + oneOf: + - $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionReferenceTableQueryDefinition' + MonitorFormulaAndFunctionAggregateAugmentedDataSource: + description: Data source for aggregate augmented queries. + enum: + - aggregate_augmented_query + example: aggregate_augmented_query + type: string + x-enum-varnames: + - AGGREGATE_AUGMENTED_QUERY + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition: + additionalProperties: false + description: A formula and functions aggregate augmented query. Used to enrich + base query results with data from a reference table. + properties: + augment_query: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateAugmentQuery' + base_query: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateBaseQuery' + compute: + description: Compute options for the query. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinitionCompute' + minItems: 1 + type: array + data_source: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateAugmentedDataSource' + group_by: + description: Group by options for the query. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryGroupBy' + type: array + join_condition: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateQueryJoinCondition' + name: + description: Name of the query for use in formulas. + example: query1 + type: string + required: + - data_source + - base_query + - augment_query + - join_condition + - compute + - group_by + type: object + MonitorFormulaAndFunctionAggregateBaseQuery: + description: Base query for aggregate queries. Can be an events query or a metrics + query. + oneOf: + - $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionMetricsQueryDefinition' + MonitorFormulaAndFunctionAggregateFilterQuery: + description: Filter query for aggregate filtered queries. Can be an events query + or a reference table query. + oneOf: + - $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionReferenceTableQueryDefinition' + MonitorFormulaAndFunctionAggregateFilteredDataSource: + description: Data source for aggregate filtered queries. + enum: + - aggregate_filtered_query + example: aggregate_filtered_query + type: string + x-enum-varnames: + - AGGREGATE_FILTERED_QUERY + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition: + additionalProperties: false + description: A formula and functions aggregate filtered query. Used to filter + base query results using data from another source. + properties: + base_query: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateBaseQuery' + compute: + description: Compute options for the query. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinitionCompute' + type: array + data_source: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateFilteredDataSource' + filter_query: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateFilterQuery' + filters: + description: Filter conditions for the query. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateQueryFilter' + type: array + group_by: + description: Group by options for the query. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryGroupBy' + type: array + name: + description: Name of the query for use in formulas. + example: query1 + type: string + required: + - data_source + - base_query + - filter_query + - filters + type: object + MonitorFormulaAndFunctionAggregateQueryFilter: + additionalProperties: false + description: Filter definition for aggregate filtered queries. + properties: + base_attribute: + description: Attribute from the base query to filter on. + example: org_id + type: string + exclude: + default: false + description: Whether to exclude matching records instead of including them. + type: boolean + filter_attribute: + description: Attribute from the filter query to match against. + example: org_id + type: string + required: + - base_attribute + - filter_attribute + type: object + MonitorFormulaAndFunctionAggregateQueryJoinCondition: + additionalProperties: false + description: Join condition for aggregate augmented queries. + properties: + augment_attribute: + description: Attribute from the augment query to join on. + example: org_id + type: string + base_attribute: + description: Attribute from the base query to join on. + example: org_id + type: string + join_type: + $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateQueryJoinType' + required: + - base_attribute + - augment_attribute + - join_type + type: object + MonitorFormulaAndFunctionAggregateQueryJoinType: + description: Join type for aggregate query join conditions. + enum: + - inner + - left + example: inner + type: string + x-enum-varnames: + - INNER + - LEFT MonitorFormulaAndFunctionCostAggregator: description: Aggregation methods for metric queries. enum: @@ -7971,6 +8126,11 @@ components: description: Measurable attribute to compute. example: '@duration' type: string + name: + description: The name assigned to this aggregation, when multiple aggregations + are defined for a query. + example: compute_result + type: string required: - aggregation type: object @@ -8040,12 +8200,122 @@ components: - DATABASE_QUERIES - NETWORK - NETWORK_PATH + MonitorFormulaAndFunctionMetricsAggregator: + description: Aggregator for metrics queries. + enum: + - avg + - min + - max + - sum + - last + - mean + - area + - l2norm + - percentile + - stddev + - count_unique + example: avg + type: string + x-enum-varnames: + - AVG + - MIN + - MAX + - SUM + - LAST + - MEAN + - AREA + - L2NORM + - PERCENTILE + - STDDEV + - COUNT_UNIQUE + MonitorFormulaAndFunctionMetricsDataSource: + description: Data source for metrics queries. + enum: + - metrics + - cloud_cost + - datadog_usage + example: metrics + type: string + x-enum-varnames: + - METRICS + - CLOUD_COST + - DATADOG_USAGE + MonitorFormulaAndFunctionMetricsQueryDefinition: + additionalProperties: false + description: A formula and functions metrics query for use in aggregate queries. + properties: + aggregator: + $ref: '#/components/schemas/MonitorFormulaAndFunctionMetricsAggregator' + data_source: + $ref: '#/components/schemas/MonitorFormulaAndFunctionMetricsDataSource' + name: + description: Name of the query for use in formulas. + example: query1 + type: string + query: + description: The metrics query definition. + example: avg:system.cpu.user{*} + type: string + required: + - data_source + - query + type: object MonitorFormulaAndFunctionQueryDefinition: description: A formula and function query. oneOf: - $ref: '#/components/schemas/MonitorFormulaAndFunctionEventQueryDefinition' - $ref: '#/components/schemas/MonitorFormulaAndFunctionCostQueryDefinition' - $ref: '#/components/schemas/MonitorFormulaAndFunctionDataQualityQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition' + - $ref: '#/components/schemas/MonitorFormulaAndFunctionAggregateFilteredQueryDefinition' + MonitorFormulaAndFunctionReferenceTableColumn: + additionalProperties: false + description: A column definition for reference table queries. + properties: + alias: + description: Optional alias for the column. + type: string + name: + description: Name of the column. + example: org_id + type: string + required: + - name + type: object + MonitorFormulaAndFunctionReferenceTableDataSource: + description: Data source for reference table queries. + enum: + - reference_table + example: reference_table + type: string + x-enum-varnames: + - REFERENCE_TABLE + MonitorFormulaAndFunctionReferenceTableQueryDefinition: + additionalProperties: false + description: A reference table query for use in aggregate queries. + properties: + columns: + description: List of columns to retrieve from the reference table. + items: + $ref: '#/components/schemas/MonitorFormulaAndFunctionReferenceTableColumn' + type: array + data_source: + $ref: '#/components/schemas/MonitorFormulaAndFunctionReferenceTableDataSource' + name: + description: Name of the query. + example: filter_query + type: string + query_filter: + description: Optional filter expression for the reference table query. + type: string + table_name: + description: Name of the reference table. + example: test_table + type: string + required: + - data_source + - table_name + type: object MonitorGroupSearchResponse: description: The response of a monitor group search. example: diff --git a/examples/v1/monitors/CreateMonitor_2082938111.java b/examples/v1/monitors/CreateMonitor_2082938111.java new file mode 100644 index 00000000000..79a5a5a54d1 --- /dev/null +++ b/examples/v1/monitors/CreateMonitor_2082938111.java @@ -0,0 +1,86 @@ +// Create a monitor with aggregate filtered query variables 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.MonitorFormulaAndFunctionAggregateBaseQuery; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateFilterQuery; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateFilteredDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateFilteredQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateQueryFilter; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionMetricsDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionMetricsQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableColumn; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableQueryDefinition; +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.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.QUERY_ALERT) + .query(""" +formula("query1").rollup("sum").last("5m") > 100 +""") + .message("test message") + .options( + new MonitorOptions() + .thresholds(new MonitorThresholds().critical(100.0)) + .variables( + Collections.singletonList( + new MonitorFormulaAndFunctionQueryDefinition( + new MonitorFormulaAndFunctionAggregateFilteredQueryDefinition() + .dataSource( + MonitorFormulaAndFunctionAggregateFilteredDataSource + .AGGREGATE_FILTERED_QUERY) + .name("query1") + .baseQuery( + new MonitorFormulaAndFunctionAggregateBaseQuery( + new MonitorFormulaAndFunctionMetricsQueryDefinition() + .dataSource( + MonitorFormulaAndFunctionMetricsDataSource + .METRICS) + .name("query1") + .query( + "max:container.cpu.usage{*} by" + + " {kube_cluster_name}.rollup(max)"))) + .filterQuery( + new MonitorFormulaAndFunctionAggregateFilterQuery( + new MonitorFormulaAndFunctionReferenceTableQueryDefinition() + .name("filter_query") + .dataSource( + MonitorFormulaAndFunctionReferenceTableDataSource + .REFERENCE_TABLE) + .tableName("test_table") + .columns( + Collections.singletonList( + new MonitorFormulaAndFunctionReferenceTableColumn() + .name("cluster_name"))))) + .filters( + Collections.singletonList( + new MonitorFormulaAndFunctionAggregateQueryFilter() + .baseAttribute("kube_cluster_name") + .filterAttribute("cluster_name"))))))); + + 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_2608995690.java b/examples/v1/monitors/CreateMonitor_2608995690.java new file mode 100644 index 00000000000..979e2964c6a --- /dev/null +++ b/examples/v1/monitors/CreateMonitor_2608995690.java @@ -0,0 +1,105 @@ +// Create a monitor with aggregate augmented query variables 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.MonitorFormulaAndFunctionAggregateAugmentQuery; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateAugmentedDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateBaseQuery; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateQueryJoinCondition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionAggregateQueryJoinType; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionEventAggregation; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionEventQueryDefinitionCompute; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionEventQueryGroupBy; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionMetricsDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionMetricsQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionQueryDefinition; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableColumn; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableDataSource; +import com.datadog.api.client.v1.model.MonitorFormulaAndFunctionReferenceTableQueryDefinition; +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.QUERY_ALERT) + .query(""" +formula("query1").rollup("sum").last("5m") > 124 +""") + .message("test message") + .options( + new MonitorOptions() + .thresholds(new MonitorThresholds().critical(124.0)) + .variables( + Collections.singletonList( + new MonitorFormulaAndFunctionQueryDefinition( + new MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition() + .dataSource( + MonitorFormulaAndFunctionAggregateAugmentedDataSource + .AGGREGATE_AUGMENTED_QUERY) + .name("query1") + .groupBy( + Arrays.asList( + new MonitorFormulaAndFunctionEventQueryGroupBy() + .facet("org_id"), + new MonitorFormulaAndFunctionEventQueryGroupBy() + .facet("name"))) + .compute( + Collections.singletonList( + new MonitorFormulaAndFunctionEventQueryDefinitionCompute() + .name("compute_result") + .aggregation( + MonitorFormulaAndFunctionEventAggregation.MAX))) + .augmentQuery( + new MonitorFormulaAndFunctionAggregateAugmentQuery( + new MonitorFormulaAndFunctionReferenceTableQueryDefinition() + .name("filter_query") + .dataSource( + MonitorFormulaAndFunctionReferenceTableDataSource + .REFERENCE_TABLE) + .tableName("test_table") + .columns( + Arrays.asList( + new MonitorFormulaAndFunctionReferenceTableColumn() + .name("org_id"), + new MonitorFormulaAndFunctionReferenceTableColumn() + .name("name"))))) + .baseQuery( + new MonitorFormulaAndFunctionAggregateBaseQuery( + new MonitorFormulaAndFunctionMetricsQueryDefinition() + .dataSource( + MonitorFormulaAndFunctionMetricsDataSource + .METRICS) + .name("query1") + .query("avg:dd{*} by {org_id}.as_count()"))) + .joinCondition( + new MonitorFormulaAndFunctionAggregateQueryJoinCondition() + .augmentAttribute("org_id") + .baseAttribute("org_id") + .joinType( + MonitorFormulaAndFunctionAggregateQueryJoinType + .INNER)))))); + + 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/MonitorFormulaAndFunctionAggregateAugmentQuery.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentQuery.java new file mode 100644 index 00000000000..33cc116868a --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentQuery.java @@ -0,0 +1,331 @@ +/* + * 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.AbstractOpenApiSchema; +import com.datadog.api.client.JSON; +import com.datadog.api.client.UnparsedObject; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import jakarta.ws.rs.core.GenericType; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +@JsonDeserialize( + using = + MonitorFormulaAndFunctionAggregateAugmentQuery + .MonitorFormulaAndFunctionAggregateAugmentQueryDeserializer.class) +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateAugmentQuery + .MonitorFormulaAndFunctionAggregateAugmentQuerySerializer.class) +public class MonitorFormulaAndFunctionAggregateAugmentQuery extends AbstractOpenApiSchema { + private static final Logger log = + Logger.getLogger(MonitorFormulaAndFunctionAggregateAugmentQuery.class.getName()); + + @JsonIgnore public boolean unparsed = false; + + public static class MonitorFormulaAndFunctionAggregateAugmentQuerySerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateAugmentQuerySerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateAugmentQuerySerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateAugmentQuery value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.getActualInstance()); + } + } + + public static class MonitorFormulaAndFunctionAggregateAugmentQueryDeserializer + extends StdDeserializer { + public MonitorFormulaAndFunctionAggregateAugmentQueryDeserializer() { + this(MonitorFormulaAndFunctionAggregateAugmentQuery.class); + } + + public MonitorFormulaAndFunctionAggregateAugmentQueryDeserializer(Class vc) { + super(vc); + } + + @Override + public MonitorFormulaAndFunctionAggregateAugmentQuery deserialize( + JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { + JsonNode tree = jp.readValueAsTree(); + Object deserialized = null; + Object tmp = null; + boolean typeCoercion = ctxt.isEnabled(MapperFeature.ALLOW_COERCION_OF_SCALARS); + int match = 0; + JsonToken token = tree.traverse(jp.getCodec()).nextToken(); + // deserialize MonitorFormulaAndFunctionEventQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionEventQueryDefinition.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 (!((MonitorFormulaAndFunctionEventQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionEventQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'MonitorFormulaAndFunctionEventQueryDefinition'", + e); + } + + // deserialize MonitorFormulaAndFunctionReferenceTableQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionReferenceTableQueryDefinition.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 (!((MonitorFormulaAndFunctionReferenceTableQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionReferenceTableQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'MonitorFormulaAndFunctionReferenceTableQueryDefinition'", + e); + } + + MonitorFormulaAndFunctionAggregateAugmentQuery ret = + new MonitorFormulaAndFunctionAggregateAugmentQuery(); + if (match == 1) { + ret.setActualInstance(deserialized); + } else { + Map res = + new ObjectMapper() + .readValue( + tree.traverse(jp.getCodec()).readValueAsTree().toString(), + new TypeReference>() {}); + ret.setActualInstance(new UnparsedObject(res)); + } + return ret; + } + + /** Handle deserialization of the 'null' value. */ + @Override + public MonitorFormulaAndFunctionAggregateAugmentQuery getNullValue(DeserializationContext ctxt) + throws JsonMappingException { + throw new JsonMappingException( + ctxt.getParser(), "MonitorFormulaAndFunctionAggregateAugmentQuery cannot be null"); + } + } + + // store a list of schema names defined in oneOf + public static final Map schemas = new HashMap(); + + public MonitorFormulaAndFunctionAggregateAugmentQuery() { + super("oneOf", Boolean.FALSE); + } + + public MonitorFormulaAndFunctionAggregateAugmentQuery( + MonitorFormulaAndFunctionEventQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public MonitorFormulaAndFunctionAggregateAugmentQuery( + MonitorFormulaAndFunctionReferenceTableQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + static { + schemas.put( + "MonitorFormulaAndFunctionEventQueryDefinition", + new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionReferenceTableQueryDefinition", + new GenericType() {}); + JSON.registerDescendants( + MonitorFormulaAndFunctionAggregateAugmentQuery.class, Collections.unmodifiableMap(schemas)); + } + + @Override + public Map getSchemas() { + return MonitorFormulaAndFunctionAggregateAugmentQuery.schemas; + } + + /** + * Set the instance that matches the oneOf child schema, check the instance parameter is valid + * against the oneOf child schemas: MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition + * + *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a + * composed schema (allOf, anyOf, oneOf). + */ + @Override + public void setActualInstance(Object instance) { + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionEventQueryDefinition.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionReferenceTableQueryDefinition.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + + if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + throw new RuntimeException( + "Invalid instance type. Must be MonitorFormulaAndFunctionEventQueryDefinition," + + " MonitorFormulaAndFunctionReferenceTableQueryDefinition"); + } + + /** + * Get the actual instance, which can be the following: + * MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition + * + * @return The actual instance (MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition) + */ + @Override + public Object getActualInstance() { + return super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionEventQueryDefinition`. If the actual + * instance is not `MonitorFormulaAndFunctionEventQueryDefinition`, the ClassCastException will be + * thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionEventQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionEventQueryDefinition` + */ + public MonitorFormulaAndFunctionEventQueryDefinition + getMonitorFormulaAndFunctionEventQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionEventQueryDefinition) super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionReferenceTableQueryDefinition`. If the + * actual instance is not `MonitorFormulaAndFunctionReferenceTableQueryDefinition`, the + * ClassCastException will be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionReferenceTableQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionReferenceTableQueryDefinition` + */ + public MonitorFormulaAndFunctionReferenceTableQueryDefinition + getMonitorFormulaAndFunctionReferenceTableQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionReferenceTableQueryDefinition) super.getActualInstance(); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedDataSource.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedDataSource.java new file mode 100644 index 00000000000..fd469b482da --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedDataSource.java @@ -0,0 +1,64 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.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 aggregate augmented queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateAugmentedDataSource + .MonitorFormulaAndFunctionAggregateAugmentedDataSourceSerializer.class) +public class MonitorFormulaAndFunctionAggregateAugmentedDataSource extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("aggregate_augmented_query")); + + public static final MonitorFormulaAndFunctionAggregateAugmentedDataSource + AGGREGATE_AUGMENTED_QUERY = + new MonitorFormulaAndFunctionAggregateAugmentedDataSource("aggregate_augmented_query"); + + MonitorFormulaAndFunctionAggregateAugmentedDataSource(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionAggregateAugmentedDataSourceSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateAugmentedDataSourceSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateAugmentedDataSourceSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateAugmentedDataSource value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionAggregateAugmentedDataSource fromValue(String value) { + return new MonitorFormulaAndFunctionAggregateAugmentedDataSource(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.java new file mode 100644 index 00000000000..04b4e6d33a0 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.java @@ -0,0 +1,321 @@ +/* + * 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.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.List; +import java.util.Objects; + +/** + * A formula and functions aggregate augmented query. Used to enrich base query results with data + * from a reference table. + */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_AUGMENT_QUERY, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_BASE_QUERY, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_COMPUTE, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_DATA_SOURCE, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_GROUP_BY, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_JOIN_CONDITION, + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.JSON_PROPERTY_NAME +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_AUGMENT_QUERY = "augment_query"; + private MonitorFormulaAndFunctionAggregateAugmentQuery augmentQuery; + + public static final String JSON_PROPERTY_BASE_QUERY = "base_query"; + private MonitorFormulaAndFunctionAggregateBaseQuery baseQuery; + + public static final String JSON_PROPERTY_COMPUTE = "compute"; + private List compute = new ArrayList<>(); + + public static final String JSON_PROPERTY_DATA_SOURCE = "data_source"; + private MonitorFormulaAndFunctionAggregateAugmentedDataSource dataSource; + + public static final String JSON_PROPERTY_GROUP_BY = "group_by"; + private List groupBy = new ArrayList<>(); + + public static final String JSON_PROPERTY_JOIN_CONDITION = "join_condition"; + private MonitorFormulaAndFunctionAggregateQueryJoinCondition joinCondition; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition() {} + + @JsonCreator + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition( + @JsonProperty(required = true, value = JSON_PROPERTY_AUGMENT_QUERY) + MonitorFormulaAndFunctionAggregateAugmentQuery augmentQuery, + @JsonProperty(required = true, value = JSON_PROPERTY_BASE_QUERY) + MonitorFormulaAndFunctionAggregateBaseQuery baseQuery, + @JsonProperty(required = true, value = JSON_PROPERTY_COMPUTE) + List compute, + @JsonProperty(required = true, value = JSON_PROPERTY_DATA_SOURCE) + MonitorFormulaAndFunctionAggregateAugmentedDataSource dataSource, + @JsonProperty(required = true, value = JSON_PROPERTY_GROUP_BY) + List groupBy, + @JsonProperty(required = true, value = JSON_PROPERTY_JOIN_CONDITION) + MonitorFormulaAndFunctionAggregateQueryJoinCondition joinCondition) { + this.augmentQuery = augmentQuery; + this.unparsed |= augmentQuery.unparsed; + this.baseQuery = baseQuery; + this.unparsed |= baseQuery.unparsed; + this.compute = compute; + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + this.groupBy = groupBy; + this.joinCondition = joinCondition; + this.unparsed |= joinCondition.unparsed; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition augmentQuery( + MonitorFormulaAndFunctionAggregateAugmentQuery augmentQuery) { + this.augmentQuery = augmentQuery; + this.unparsed |= augmentQuery.unparsed; + return this; + } + + /** + * Augment query for aggregate augmented queries. Can be an events query or a reference table + * query. + * + * @return augmentQuery + */ + @JsonProperty(JSON_PROPERTY_AUGMENT_QUERY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateAugmentQuery getAugmentQuery() { + return augmentQuery; + } + + public void setAugmentQuery(MonitorFormulaAndFunctionAggregateAugmentQuery augmentQuery) { + this.augmentQuery = augmentQuery; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition baseQuery( + MonitorFormulaAndFunctionAggregateBaseQuery baseQuery) { + this.baseQuery = baseQuery; + this.unparsed |= baseQuery.unparsed; + return this; + } + + /** + * Base query for aggregate queries. Can be an events query or a metrics query. + * + * @return baseQuery + */ + @JsonProperty(JSON_PROPERTY_BASE_QUERY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateBaseQuery getBaseQuery() { + return baseQuery; + } + + public void setBaseQuery(MonitorFormulaAndFunctionAggregateBaseQuery baseQuery) { + this.baseQuery = baseQuery; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition compute( + List compute) { + this.compute = compute; + for (MonitorFormulaAndFunctionEventQueryDefinitionCompute item : compute) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition addComputeItem( + MonitorFormulaAndFunctionEventQueryDefinitionCompute computeItem) { + this.compute.add(computeItem); + this.unparsed |= computeItem.unparsed; + return this; + } + + /** + * Compute options for the query. + * + * @return compute + */ + @JsonProperty(JSON_PROPERTY_COMPUTE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getCompute() { + return compute; + } + + public void setCompute(List compute) { + this.compute = compute; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition dataSource( + MonitorFormulaAndFunctionAggregateAugmentedDataSource dataSource) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + return this; + } + + /** + * Data source for aggregate augmented queries. + * + * @return dataSource + */ + @JsonProperty(JSON_PROPERTY_DATA_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateAugmentedDataSource getDataSource() { + return dataSource; + } + + public void setDataSource(MonitorFormulaAndFunctionAggregateAugmentedDataSource dataSource) { + if (!dataSource.isValid()) { + this.unparsed = true; + } + this.dataSource = dataSource; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition groupBy( + List groupBy) { + this.groupBy = groupBy; + for (MonitorFormulaAndFunctionEventQueryGroupBy item : groupBy) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition addGroupByItem( + MonitorFormulaAndFunctionEventQueryGroupBy groupByItem) { + this.groupBy.add(groupByItem); + this.unparsed |= groupByItem.unparsed; + return this; + } + + /** + * Group by options for the query. + * + * @return groupBy + */ + @JsonProperty(JSON_PROPERTY_GROUP_BY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getGroupBy() { + return groupBy; + } + + public void setGroupBy(List groupBy) { + this.groupBy = groupBy; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition joinCondition( + MonitorFormulaAndFunctionAggregateQueryJoinCondition joinCondition) { + this.joinCondition = joinCondition; + this.unparsed |= joinCondition.unparsed; + return this; + } + + /** + * Join condition for aggregate augmented queries. + * + * @return joinCondition + */ + @JsonProperty(JSON_PROPERTY_JOIN_CONDITION) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateQueryJoinCondition getJoinCondition() { + return joinCondition; + } + + public void setJoinCondition(MonitorFormulaAndFunctionAggregateQueryJoinCondition joinCondition) { + this.joinCondition = joinCondition; + } + + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition name(String name) { + this.name = name; + return this; + } + + /** + * Name of the query for use in formulas. + * + * @return name + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * Return true if this MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition object is equal + * to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition + monitorFormulaAndFunctionAggregateAugmentedQueryDefinition = + (MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition) o; + return Objects.equals( + this.augmentQuery, + monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.augmentQuery) + && Objects.equals( + this.baseQuery, monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.baseQuery) + && Objects.equals( + this.compute, monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.compute) + && Objects.equals( + this.dataSource, monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.dataSource) + && Objects.equals( + this.groupBy, monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.groupBy) + && Objects.equals( + this.joinCondition, + monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.joinCondition) + && Objects.equals( + this.name, monitorFormulaAndFunctionAggregateAugmentedQueryDefinition.name); + } + + @Override + public int hashCode() { + return Objects.hash(augmentQuery, baseQuery, compute, dataSource, groupBy, joinCondition, name); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition {\n"); + sb.append(" augmentQuery: ").append(toIndentedString(augmentQuery)).append("\n"); + sb.append(" baseQuery: ").append(toIndentedString(baseQuery)).append("\n"); + sb.append(" compute: ").append(toIndentedString(compute)).append("\n"); + sb.append(" dataSource: ").append(toIndentedString(dataSource)).append("\n"); + sb.append(" groupBy: ").append(toIndentedString(groupBy)).append("\n"); + sb.append(" joinCondition: ").append(toIndentedString(joinCondition)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).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/MonitorFormulaAndFunctionAggregateBaseQuery.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateBaseQuery.java new file mode 100644 index 00000000000..8d2018a8d47 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateBaseQuery.java @@ -0,0 +1,326 @@ +/* + * 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.AbstractOpenApiSchema; +import com.datadog.api.client.JSON; +import com.datadog.api.client.UnparsedObject; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import jakarta.ws.rs.core.GenericType; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +@JsonDeserialize( + using = + MonitorFormulaAndFunctionAggregateBaseQuery + .MonitorFormulaAndFunctionAggregateBaseQueryDeserializer.class) +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateBaseQuery + .MonitorFormulaAndFunctionAggregateBaseQuerySerializer.class) +public class MonitorFormulaAndFunctionAggregateBaseQuery extends AbstractOpenApiSchema { + private static final Logger log = + Logger.getLogger(MonitorFormulaAndFunctionAggregateBaseQuery.class.getName()); + + @JsonIgnore public boolean unparsed = false; + + public static class MonitorFormulaAndFunctionAggregateBaseQuerySerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateBaseQuerySerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateBaseQuerySerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateBaseQuery value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.getActualInstance()); + } + } + + public static class MonitorFormulaAndFunctionAggregateBaseQueryDeserializer + extends StdDeserializer { + public MonitorFormulaAndFunctionAggregateBaseQueryDeserializer() { + this(MonitorFormulaAndFunctionAggregateBaseQuery.class); + } + + public MonitorFormulaAndFunctionAggregateBaseQueryDeserializer(Class vc) { + super(vc); + } + + @Override + public MonitorFormulaAndFunctionAggregateBaseQuery deserialize( + JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { + JsonNode tree = jp.readValueAsTree(); + Object deserialized = null; + Object tmp = null; + boolean typeCoercion = ctxt.isEnabled(MapperFeature.ALLOW_COERCION_OF_SCALARS); + int match = 0; + JsonToken token = tree.traverse(jp.getCodec()).nextToken(); + // deserialize MonitorFormulaAndFunctionEventQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionEventQueryDefinition.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 (!((MonitorFormulaAndFunctionEventQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionEventQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'MonitorFormulaAndFunctionEventQueryDefinition'", + e); + } + + // deserialize MonitorFormulaAndFunctionMetricsQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionMetricsQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionMetricsQueryDefinition.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 (!((MonitorFormulaAndFunctionMetricsQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionMetricsQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'MonitorFormulaAndFunctionMetricsQueryDefinition'", + e); + } + + MonitorFormulaAndFunctionAggregateBaseQuery ret = + new MonitorFormulaAndFunctionAggregateBaseQuery(); + if (match == 1) { + ret.setActualInstance(deserialized); + } else { + Map res = + new ObjectMapper() + .readValue( + tree.traverse(jp.getCodec()).readValueAsTree().toString(), + new TypeReference>() {}); + ret.setActualInstance(new UnparsedObject(res)); + } + return ret; + } + + /** Handle deserialization of the 'null' value. */ + @Override + public MonitorFormulaAndFunctionAggregateBaseQuery getNullValue(DeserializationContext ctxt) + throws JsonMappingException { + throw new JsonMappingException( + ctxt.getParser(), "MonitorFormulaAndFunctionAggregateBaseQuery cannot be null"); + } + } + + // store a list of schema names defined in oneOf + public static final Map schemas = new HashMap(); + + public MonitorFormulaAndFunctionAggregateBaseQuery() { + super("oneOf", Boolean.FALSE); + } + + public MonitorFormulaAndFunctionAggregateBaseQuery( + MonitorFormulaAndFunctionEventQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public MonitorFormulaAndFunctionAggregateBaseQuery( + MonitorFormulaAndFunctionMetricsQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + static { + schemas.put( + "MonitorFormulaAndFunctionEventQueryDefinition", + new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionMetricsQueryDefinition", + new GenericType() {}); + JSON.registerDescendants( + MonitorFormulaAndFunctionAggregateBaseQuery.class, Collections.unmodifiableMap(schemas)); + } + + @Override + public Map getSchemas() { + return MonitorFormulaAndFunctionAggregateBaseQuery.schemas; + } + + /** + * Set the instance that matches the oneOf child schema, check the instance parameter is valid + * against the oneOf child schemas: MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionMetricsQueryDefinition + * + *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a + * composed schema (allOf, anyOf, oneOf). + */ + @Override + public void setActualInstance(Object instance) { + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionEventQueryDefinition.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionMetricsQueryDefinition.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + + if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + throw new RuntimeException( + "Invalid instance type. Must be MonitorFormulaAndFunctionEventQueryDefinition," + + " MonitorFormulaAndFunctionMetricsQueryDefinition"); + } + + /** + * Get the actual instance, which can be the following: + * MonitorFormulaAndFunctionEventQueryDefinition, MonitorFormulaAndFunctionMetricsQueryDefinition + * + * @return The actual instance (MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionMetricsQueryDefinition) + */ + @Override + public Object getActualInstance() { + return super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionEventQueryDefinition`. If the actual + * instance is not `MonitorFormulaAndFunctionEventQueryDefinition`, the ClassCastException will be + * thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionEventQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionEventQueryDefinition` + */ + public MonitorFormulaAndFunctionEventQueryDefinition + getMonitorFormulaAndFunctionEventQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionEventQueryDefinition) super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionMetricsQueryDefinition`. If the actual + * instance is not `MonitorFormulaAndFunctionMetricsQueryDefinition`, the ClassCastException will + * be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionMetricsQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionMetricsQueryDefinition` + */ + public MonitorFormulaAndFunctionMetricsQueryDefinition + getMonitorFormulaAndFunctionMetricsQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionMetricsQueryDefinition) super.getActualInstance(); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilterQuery.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilterQuery.java new file mode 100644 index 00000000000..b919a5a08a4 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilterQuery.java @@ -0,0 +1,331 @@ +/* + * 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.AbstractOpenApiSchema; +import com.datadog.api.client.JSON; +import com.datadog.api.client.UnparsedObject; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import jakarta.ws.rs.core.GenericType; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +@JsonDeserialize( + using = + MonitorFormulaAndFunctionAggregateFilterQuery + .MonitorFormulaAndFunctionAggregateFilterQueryDeserializer.class) +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateFilterQuery + .MonitorFormulaAndFunctionAggregateFilterQuerySerializer.class) +public class MonitorFormulaAndFunctionAggregateFilterQuery extends AbstractOpenApiSchema { + private static final Logger log = + Logger.getLogger(MonitorFormulaAndFunctionAggregateFilterQuery.class.getName()); + + @JsonIgnore public boolean unparsed = false; + + public static class MonitorFormulaAndFunctionAggregateFilterQuerySerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateFilterQuerySerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateFilterQuerySerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateFilterQuery value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.getActualInstance()); + } + } + + public static class MonitorFormulaAndFunctionAggregateFilterQueryDeserializer + extends StdDeserializer { + public MonitorFormulaAndFunctionAggregateFilterQueryDeserializer() { + this(MonitorFormulaAndFunctionAggregateFilterQuery.class); + } + + public MonitorFormulaAndFunctionAggregateFilterQueryDeserializer(Class vc) { + super(vc); + } + + @Override + public MonitorFormulaAndFunctionAggregateFilterQuery deserialize( + JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { + JsonNode tree = jp.readValueAsTree(); + Object deserialized = null; + Object tmp = null; + boolean typeCoercion = ctxt.isEnabled(MapperFeature.ALLOW_COERCION_OF_SCALARS); + int match = 0; + JsonToken token = tree.traverse(jp.getCodec()).nextToken(); + // deserialize MonitorFormulaAndFunctionEventQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionEventQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionEventQueryDefinition.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 (!((MonitorFormulaAndFunctionEventQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionEventQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'MonitorFormulaAndFunctionEventQueryDefinition'", + e); + } + + // deserialize MonitorFormulaAndFunctionReferenceTableQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionReferenceTableQueryDefinition.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionReferenceTableQueryDefinition.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 (!((MonitorFormulaAndFunctionReferenceTableQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema 'MonitorFormulaAndFunctionReferenceTableQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'MonitorFormulaAndFunctionReferenceTableQueryDefinition'", + e); + } + + MonitorFormulaAndFunctionAggregateFilterQuery ret = + new MonitorFormulaAndFunctionAggregateFilterQuery(); + if (match == 1) { + ret.setActualInstance(deserialized); + } else { + Map res = + new ObjectMapper() + .readValue( + tree.traverse(jp.getCodec()).readValueAsTree().toString(), + new TypeReference>() {}); + ret.setActualInstance(new UnparsedObject(res)); + } + return ret; + } + + /** Handle deserialization of the 'null' value. */ + @Override + public MonitorFormulaAndFunctionAggregateFilterQuery getNullValue(DeserializationContext ctxt) + throws JsonMappingException { + throw new JsonMappingException( + ctxt.getParser(), "MonitorFormulaAndFunctionAggregateFilterQuery cannot be null"); + } + } + + // store a list of schema names defined in oneOf + public static final Map schemas = new HashMap(); + + public MonitorFormulaAndFunctionAggregateFilterQuery() { + super("oneOf", Boolean.FALSE); + } + + public MonitorFormulaAndFunctionAggregateFilterQuery( + MonitorFormulaAndFunctionEventQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public MonitorFormulaAndFunctionAggregateFilterQuery( + MonitorFormulaAndFunctionReferenceTableQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + static { + schemas.put( + "MonitorFormulaAndFunctionEventQueryDefinition", + new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionReferenceTableQueryDefinition", + new GenericType() {}); + JSON.registerDescendants( + MonitorFormulaAndFunctionAggregateFilterQuery.class, Collections.unmodifiableMap(schemas)); + } + + @Override + public Map getSchemas() { + return MonitorFormulaAndFunctionAggregateFilterQuery.schemas; + } + + /** + * Set the instance that matches the oneOf child schema, check the instance parameter is valid + * against the oneOf child schemas: MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition + * + *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a + * composed schema (allOf, anyOf, oneOf). + */ + @Override + public void setActualInstance(Object instance) { + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionEventQueryDefinition.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionReferenceTableQueryDefinition.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + + if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } + throw new RuntimeException( + "Invalid instance type. Must be MonitorFormulaAndFunctionEventQueryDefinition," + + " MonitorFormulaAndFunctionReferenceTableQueryDefinition"); + } + + /** + * Get the actual instance, which can be the following: + * MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition + * + * @return The actual instance (MonitorFormulaAndFunctionEventQueryDefinition, + * MonitorFormulaAndFunctionReferenceTableQueryDefinition) + */ + @Override + public Object getActualInstance() { + return super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionEventQueryDefinition`. If the actual + * instance is not `MonitorFormulaAndFunctionEventQueryDefinition`, the ClassCastException will be + * thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionEventQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionEventQueryDefinition` + */ + public MonitorFormulaAndFunctionEventQueryDefinition + getMonitorFormulaAndFunctionEventQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionEventQueryDefinition) super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionReferenceTableQueryDefinition`. If the + * actual instance is not `MonitorFormulaAndFunctionReferenceTableQueryDefinition`, the + * ClassCastException will be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionReferenceTableQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionReferenceTableQueryDefinition` + */ + public MonitorFormulaAndFunctionReferenceTableQueryDefinition + getMonitorFormulaAndFunctionReferenceTableQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionReferenceTableQueryDefinition) super.getActualInstance(); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredDataSource.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredDataSource.java new file mode 100644 index 00000000000..5c02be66d55 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredDataSource.java @@ -0,0 +1,64 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.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 aggregate filtered queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateFilteredDataSource + .MonitorFormulaAndFunctionAggregateFilteredDataSourceSerializer.class) +public class MonitorFormulaAndFunctionAggregateFilteredDataSource extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("aggregate_filtered_query")); + + public static final MonitorFormulaAndFunctionAggregateFilteredDataSource + AGGREGATE_FILTERED_QUERY = + new MonitorFormulaAndFunctionAggregateFilteredDataSource("aggregate_filtered_query"); + + MonitorFormulaAndFunctionAggregateFilteredDataSource(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionAggregateFilteredDataSourceSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateFilteredDataSourceSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateFilteredDataSourceSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateFilteredDataSource value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionAggregateFilteredDataSource fromValue(String value) { + return new MonitorFormulaAndFunctionAggregateFilteredDataSource(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.java new file mode 100644 index 00000000000..8626b952400 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.java @@ -0,0 +1,328 @@ +/* + * 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.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.List; +import java.util.Objects; + +/** + * A formula and functions aggregate filtered query. Used to filter base query results using data + * from another source. + */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_BASE_QUERY, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_COMPUTE, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_DATA_SOURCE, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_FILTER_QUERY, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_FILTERS, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_GROUP_BY, + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.JSON_PROPERTY_NAME +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionAggregateFilteredQueryDefinition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_BASE_QUERY = "base_query"; + private MonitorFormulaAndFunctionAggregateBaseQuery baseQuery; + + public static final String JSON_PROPERTY_COMPUTE = "compute"; + private List compute = null; + + public static final String JSON_PROPERTY_DATA_SOURCE = "data_source"; + private MonitorFormulaAndFunctionAggregateFilteredDataSource dataSource; + + public static final String JSON_PROPERTY_FILTER_QUERY = "filter_query"; + private MonitorFormulaAndFunctionAggregateFilterQuery filterQuery; + + public static final String JSON_PROPERTY_FILTERS = "filters"; + private List filters = new ArrayList<>(); + + public static final String JSON_PROPERTY_GROUP_BY = "group_by"; + private List groupBy = null; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition() {} + + @JsonCreator + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition( + @JsonProperty(required = true, value = JSON_PROPERTY_BASE_QUERY) + MonitorFormulaAndFunctionAggregateBaseQuery baseQuery, + @JsonProperty(required = true, value = JSON_PROPERTY_DATA_SOURCE) + MonitorFormulaAndFunctionAggregateFilteredDataSource dataSource, + @JsonProperty(required = true, value = JSON_PROPERTY_FILTER_QUERY) + MonitorFormulaAndFunctionAggregateFilterQuery filterQuery, + @JsonProperty(required = true, value = JSON_PROPERTY_FILTERS) + List filters) { + this.baseQuery = baseQuery; + this.unparsed |= baseQuery.unparsed; + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + this.filterQuery = filterQuery; + this.unparsed |= filterQuery.unparsed; + this.filters = filters; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition baseQuery( + MonitorFormulaAndFunctionAggregateBaseQuery baseQuery) { + this.baseQuery = baseQuery; + this.unparsed |= baseQuery.unparsed; + return this; + } + + /** + * Base query for aggregate queries. Can be an events query or a metrics query. + * + * @return baseQuery + */ + @JsonProperty(JSON_PROPERTY_BASE_QUERY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateBaseQuery getBaseQuery() { + return baseQuery; + } + + public void setBaseQuery(MonitorFormulaAndFunctionAggregateBaseQuery baseQuery) { + this.baseQuery = baseQuery; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition compute( + List compute) { + this.compute = compute; + for (MonitorFormulaAndFunctionEventQueryDefinitionCompute item : compute) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition addComputeItem( + MonitorFormulaAndFunctionEventQueryDefinitionCompute computeItem) { + if (this.compute == null) { + this.compute = new ArrayList<>(); + } + this.compute.add(computeItem); + this.unparsed |= computeItem.unparsed; + return this; + } + + /** + * Compute options for the query. + * + * @return compute + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_COMPUTE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getCompute() { + return compute; + } + + public void setCompute(List compute) { + this.compute = compute; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition dataSource( + MonitorFormulaAndFunctionAggregateFilteredDataSource dataSource) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + return this; + } + + /** + * Data source for aggregate filtered queries. + * + * @return dataSource + */ + @JsonProperty(JSON_PROPERTY_DATA_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateFilteredDataSource getDataSource() { + return dataSource; + } + + public void setDataSource(MonitorFormulaAndFunctionAggregateFilteredDataSource dataSource) { + if (!dataSource.isValid()) { + this.unparsed = true; + } + this.dataSource = dataSource; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition filterQuery( + MonitorFormulaAndFunctionAggregateFilterQuery filterQuery) { + this.filterQuery = filterQuery; + this.unparsed |= filterQuery.unparsed; + return this; + } + + /** + * Filter query for aggregate filtered queries. Can be an events query or a reference table query. + * + * @return filterQuery + */ + @JsonProperty(JSON_PROPERTY_FILTER_QUERY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateFilterQuery getFilterQuery() { + return filterQuery; + } + + public void setFilterQuery(MonitorFormulaAndFunctionAggregateFilterQuery filterQuery) { + this.filterQuery = filterQuery; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition filters( + List filters) { + this.filters = filters; + for (MonitorFormulaAndFunctionAggregateQueryFilter item : filters) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition addFiltersItem( + MonitorFormulaAndFunctionAggregateQueryFilter filtersItem) { + this.filters.add(filtersItem); + this.unparsed |= filtersItem.unparsed; + return this; + } + + /** + * Filter conditions for the query. + * + * @return filters + */ + @JsonProperty(JSON_PROPERTY_FILTERS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getFilters() { + return filters; + } + + public void setFilters(List filters) { + this.filters = filters; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition groupBy( + List groupBy) { + this.groupBy = groupBy; + for (MonitorFormulaAndFunctionEventQueryGroupBy item : groupBy) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition addGroupByItem( + MonitorFormulaAndFunctionEventQueryGroupBy groupByItem) { + if (this.groupBy == null) { + this.groupBy = new ArrayList<>(); + } + this.groupBy.add(groupByItem); + this.unparsed |= groupByItem.unparsed; + return this; + } + + /** + * Group by options for the query. + * + * @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 MonitorFormulaAndFunctionAggregateFilteredQueryDefinition name(String name) { + this.name = name; + return this; + } + + /** + * Name of the query for use in formulas. + * + * @return name + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * Return true if this MonitorFormulaAndFunctionAggregateFilteredQueryDefinition object is equal + * to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition + monitorFormulaAndFunctionAggregateFilteredQueryDefinition = + (MonitorFormulaAndFunctionAggregateFilteredQueryDefinition) o; + return Objects.equals( + this.baseQuery, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.baseQuery) + && Objects.equals( + this.compute, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.compute) + && Objects.equals( + this.dataSource, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.dataSource) + && Objects.equals( + this.filterQuery, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.filterQuery) + && Objects.equals( + this.filters, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.filters) + && Objects.equals( + this.groupBy, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.groupBy) + && Objects.equals( + this.name, monitorFormulaAndFunctionAggregateFilteredQueryDefinition.name); + } + + @Override + public int hashCode() { + return Objects.hash(baseQuery, compute, dataSource, filterQuery, filters, groupBy, name); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionAggregateFilteredQueryDefinition {\n"); + sb.append(" baseQuery: ").append(toIndentedString(baseQuery)).append("\n"); + sb.append(" compute: ").append(toIndentedString(compute)).append("\n"); + sb.append(" dataSource: ").append(toIndentedString(dataSource)).append("\n"); + sb.append(" filterQuery: ").append(toIndentedString(filterQuery)).append("\n"); + sb.append(" filters: ").append(toIndentedString(filters)).append("\n"); + sb.append(" groupBy: ").append(toIndentedString(groupBy)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).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/MonitorFormulaAndFunctionAggregateQueryFilter.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryFilter.java new file mode 100644 index 00000000000..3edb886f4cd --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryFilter.java @@ -0,0 +1,150 @@ +/* + * 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.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.Objects; + +/** Filter definition for aggregate filtered queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionAggregateQueryFilter.JSON_PROPERTY_BASE_ATTRIBUTE, + MonitorFormulaAndFunctionAggregateQueryFilter.JSON_PROPERTY_EXCLUDE, + MonitorFormulaAndFunctionAggregateQueryFilter.JSON_PROPERTY_FILTER_ATTRIBUTE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionAggregateQueryFilter { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_BASE_ATTRIBUTE = "base_attribute"; + private String baseAttribute; + + public static final String JSON_PROPERTY_EXCLUDE = "exclude"; + private Boolean exclude = false; + + public static final String JSON_PROPERTY_FILTER_ATTRIBUTE = "filter_attribute"; + private String filterAttribute; + + public MonitorFormulaAndFunctionAggregateQueryFilter() {} + + @JsonCreator + public MonitorFormulaAndFunctionAggregateQueryFilter( + @JsonProperty(required = true, value = JSON_PROPERTY_BASE_ATTRIBUTE) String baseAttribute, + @JsonProperty(required = true, value = JSON_PROPERTY_FILTER_ATTRIBUTE) + String filterAttribute) { + this.baseAttribute = baseAttribute; + this.filterAttribute = filterAttribute; + } + + public MonitorFormulaAndFunctionAggregateQueryFilter baseAttribute(String baseAttribute) { + this.baseAttribute = baseAttribute; + return this; + } + + /** + * Attribute from the base query to filter on. + * + * @return baseAttribute + */ + @JsonProperty(JSON_PROPERTY_BASE_ATTRIBUTE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getBaseAttribute() { + return baseAttribute; + } + + public void setBaseAttribute(String baseAttribute) { + this.baseAttribute = baseAttribute; + } + + public MonitorFormulaAndFunctionAggregateQueryFilter exclude(Boolean exclude) { + this.exclude = exclude; + return this; + } + + /** + * Whether to exclude matching records instead of including them. + * + * @return exclude + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_EXCLUDE) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public Boolean getExclude() { + return exclude; + } + + public void setExclude(Boolean exclude) { + this.exclude = exclude; + } + + public MonitorFormulaAndFunctionAggregateQueryFilter filterAttribute(String filterAttribute) { + this.filterAttribute = filterAttribute; + return this; + } + + /** + * Attribute from the filter query to match against. + * + * @return filterAttribute + */ + @JsonProperty(JSON_PROPERTY_FILTER_ATTRIBUTE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getFilterAttribute() { + return filterAttribute; + } + + public void setFilterAttribute(String filterAttribute) { + this.filterAttribute = filterAttribute; + } + + /** Return true if this MonitorFormulaAndFunctionAggregateQueryFilter object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionAggregateQueryFilter monitorFormulaAndFunctionAggregateQueryFilter = + (MonitorFormulaAndFunctionAggregateQueryFilter) o; + return Objects.equals( + this.baseAttribute, monitorFormulaAndFunctionAggregateQueryFilter.baseAttribute) + && Objects.equals(this.exclude, monitorFormulaAndFunctionAggregateQueryFilter.exclude) + && Objects.equals( + this.filterAttribute, monitorFormulaAndFunctionAggregateQueryFilter.filterAttribute); + } + + @Override + public int hashCode() { + return Objects.hash(baseAttribute, exclude, filterAttribute); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionAggregateQueryFilter {\n"); + sb.append(" baseAttribute: ").append(toIndentedString(baseAttribute)).append("\n"); + sb.append(" exclude: ").append(toIndentedString(exclude)).append("\n"); + sb.append(" filterAttribute: ").append(toIndentedString(filterAttribute)).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/MonitorFormulaAndFunctionAggregateQueryJoinCondition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryJoinCondition.java new file mode 100644 index 00000000000..5f5a2c15b8b --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryJoinCondition.java @@ -0,0 +1,164 @@ +/* + * 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.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.Objects; + +/** Join condition for aggregate augmented queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionAggregateQueryJoinCondition.JSON_PROPERTY_AUGMENT_ATTRIBUTE, + MonitorFormulaAndFunctionAggregateQueryJoinCondition.JSON_PROPERTY_BASE_ATTRIBUTE, + MonitorFormulaAndFunctionAggregateQueryJoinCondition.JSON_PROPERTY_JOIN_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionAggregateQueryJoinCondition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_AUGMENT_ATTRIBUTE = "augment_attribute"; + private String augmentAttribute; + + public static final String JSON_PROPERTY_BASE_ATTRIBUTE = "base_attribute"; + private String baseAttribute; + + public static final String JSON_PROPERTY_JOIN_TYPE = "join_type"; + private MonitorFormulaAndFunctionAggregateQueryJoinType joinType; + + public MonitorFormulaAndFunctionAggregateQueryJoinCondition() {} + + @JsonCreator + public MonitorFormulaAndFunctionAggregateQueryJoinCondition( + @JsonProperty(required = true, value = JSON_PROPERTY_AUGMENT_ATTRIBUTE) + String augmentAttribute, + @JsonProperty(required = true, value = JSON_PROPERTY_BASE_ATTRIBUTE) String baseAttribute, + @JsonProperty(required = true, value = JSON_PROPERTY_JOIN_TYPE) + MonitorFormulaAndFunctionAggregateQueryJoinType joinType) { + this.augmentAttribute = augmentAttribute; + this.baseAttribute = baseAttribute; + this.joinType = joinType; + this.unparsed |= !joinType.isValid(); + } + + public MonitorFormulaAndFunctionAggregateQueryJoinCondition augmentAttribute( + String augmentAttribute) { + this.augmentAttribute = augmentAttribute; + return this; + } + + /** + * Attribute from the augment query to join on. + * + * @return augmentAttribute + */ + @JsonProperty(JSON_PROPERTY_AUGMENT_ATTRIBUTE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getAugmentAttribute() { + return augmentAttribute; + } + + public void setAugmentAttribute(String augmentAttribute) { + this.augmentAttribute = augmentAttribute; + } + + public MonitorFormulaAndFunctionAggregateQueryJoinCondition baseAttribute(String baseAttribute) { + this.baseAttribute = baseAttribute; + return this; + } + + /** + * Attribute from the base query to join on. + * + * @return baseAttribute + */ + @JsonProperty(JSON_PROPERTY_BASE_ATTRIBUTE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getBaseAttribute() { + return baseAttribute; + } + + public void setBaseAttribute(String baseAttribute) { + this.baseAttribute = baseAttribute; + } + + public MonitorFormulaAndFunctionAggregateQueryJoinCondition joinType( + MonitorFormulaAndFunctionAggregateQueryJoinType joinType) { + this.joinType = joinType; + this.unparsed |= !joinType.isValid(); + return this; + } + + /** + * Join type for aggregate query join conditions. + * + * @return joinType + */ + @JsonProperty(JSON_PROPERTY_JOIN_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionAggregateQueryJoinType getJoinType() { + return joinType; + } + + public void setJoinType(MonitorFormulaAndFunctionAggregateQueryJoinType joinType) { + if (!joinType.isValid()) { + this.unparsed = true; + } + this.joinType = joinType; + } + + /** + * Return true if this MonitorFormulaAndFunctionAggregateQueryJoinCondition object is equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionAggregateQueryJoinCondition + monitorFormulaAndFunctionAggregateQueryJoinCondition = + (MonitorFormulaAndFunctionAggregateQueryJoinCondition) o; + return Objects.equals( + this.augmentAttribute, + monitorFormulaAndFunctionAggregateQueryJoinCondition.augmentAttribute) + && Objects.equals( + this.baseAttribute, monitorFormulaAndFunctionAggregateQueryJoinCondition.baseAttribute) + && Objects.equals( + this.joinType, monitorFormulaAndFunctionAggregateQueryJoinCondition.joinType); + } + + @Override + public int hashCode() { + return Objects.hash(augmentAttribute, baseAttribute, joinType); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionAggregateQueryJoinCondition {\n"); + sb.append(" augmentAttribute: ").append(toIndentedString(augmentAttribute)).append("\n"); + sb.append(" baseAttribute: ").append(toIndentedString(baseAttribute)).append("\n"); + sb.append(" joinType: ").append(toIndentedString(joinType)).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/MonitorFormulaAndFunctionAggregateQueryJoinType.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryJoinType.java new file mode 100644 index 00000000000..546db65903f --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionAggregateQueryJoinType.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; + +/** Join type for aggregate query join conditions. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionAggregateQueryJoinType + .MonitorFormulaAndFunctionAggregateQueryJoinTypeSerializer.class) +public class MonitorFormulaAndFunctionAggregateQueryJoinType extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("inner", "left")); + + public static final MonitorFormulaAndFunctionAggregateQueryJoinType INNER = + new MonitorFormulaAndFunctionAggregateQueryJoinType("inner"); + public static final MonitorFormulaAndFunctionAggregateQueryJoinType LEFT = + new MonitorFormulaAndFunctionAggregateQueryJoinType("left"); + + MonitorFormulaAndFunctionAggregateQueryJoinType(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionAggregateQueryJoinTypeSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionAggregateQueryJoinTypeSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionAggregateQueryJoinTypeSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionAggregateQueryJoinType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionAggregateQueryJoinType fromValue(String value) { + return new MonitorFormulaAndFunctionAggregateQueryJoinType(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionEventQueryDefinitionCompute.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionEventQueryDefinitionCompute.java index 3827465e0f6..26008488930 100644 --- a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionEventQueryDefinitionCompute.java +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionEventQueryDefinitionCompute.java @@ -21,7 +21,8 @@ @JsonPropertyOrder({ MonitorFormulaAndFunctionEventQueryDefinitionCompute.JSON_PROPERTY_AGGREGATION, MonitorFormulaAndFunctionEventQueryDefinitionCompute.JSON_PROPERTY_INTERVAL, - MonitorFormulaAndFunctionEventQueryDefinitionCompute.JSON_PROPERTY_METRIC + MonitorFormulaAndFunctionEventQueryDefinitionCompute.JSON_PROPERTY_METRIC, + MonitorFormulaAndFunctionEventQueryDefinitionCompute.JSON_PROPERTY_NAME }) @jakarta.annotation.Generated( value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") @@ -36,6 +37,9 @@ public class MonitorFormulaAndFunctionEventQueryDefinitionCompute { public static final String JSON_PROPERTY_METRIC = "metric"; private String metric; + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + public MonitorFormulaAndFunctionEventQueryDefinitionCompute() {} @JsonCreator @@ -113,6 +117,27 @@ public void setMetric(String metric) { this.metric = metric; } + public MonitorFormulaAndFunctionEventQueryDefinitionCompute name(String name) { + this.name = name; + return this; + } + + /** + * The name assigned to this aggregation, when multiple aggregations are defined for a query. + * + * @return name + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + /** * A container for additional, undeclared properties. This is a holder for any undeclared * properties as specified with the 'additionalProperties' keyword in the OAS document. @@ -179,6 +204,7 @@ public boolean equals(Object o) { && Objects.equals( this.interval, monitorFormulaAndFunctionEventQueryDefinitionCompute.interval) && Objects.equals(this.metric, monitorFormulaAndFunctionEventQueryDefinitionCompute.metric) + && Objects.equals(this.name, monitorFormulaAndFunctionEventQueryDefinitionCompute.name) && Objects.equals( this.additionalProperties, monitorFormulaAndFunctionEventQueryDefinitionCompute.additionalProperties); @@ -186,7 +212,7 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(aggregation, interval, metric, additionalProperties); + return Objects.hash(aggregation, interval, metric, name, additionalProperties); } @Override @@ -196,6 +222,7 @@ public String toString() { sb.append(" aggregation: ").append(toIndentedString(aggregation)).append("\n"); sb.append(" interval: ").append(toIndentedString(interval)).append("\n"); sb.append(" metric: ").append(toIndentedString(metric)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).append("\n"); sb.append(" additionalProperties: ") .append(toIndentedString(additionalProperties)) .append("\n"); diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsAggregator.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsAggregator.java new file mode 100644 index 00000000000..b207e273946 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsAggregator.java @@ -0,0 +1,95 @@ +/* + * 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; + +/** Aggregator for metrics queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionMetricsAggregator + .MonitorFormulaAndFunctionMetricsAggregatorSerializer.class) +public class MonitorFormulaAndFunctionMetricsAggregator extends ModelEnum { + + private static final Set allowedValues = + new HashSet( + Arrays.asList( + "avg", + "min", + "max", + "sum", + "last", + "mean", + "area", + "l2norm", + "percentile", + "stddev", + "count_unique")); + + public static final MonitorFormulaAndFunctionMetricsAggregator AVG = + new MonitorFormulaAndFunctionMetricsAggregator("avg"); + public static final MonitorFormulaAndFunctionMetricsAggregator MIN = + new MonitorFormulaAndFunctionMetricsAggregator("min"); + public static final MonitorFormulaAndFunctionMetricsAggregator MAX = + new MonitorFormulaAndFunctionMetricsAggregator("max"); + public static final MonitorFormulaAndFunctionMetricsAggregator SUM = + new MonitorFormulaAndFunctionMetricsAggregator("sum"); + public static final MonitorFormulaAndFunctionMetricsAggregator LAST = + new MonitorFormulaAndFunctionMetricsAggregator("last"); + public static final MonitorFormulaAndFunctionMetricsAggregator MEAN = + new MonitorFormulaAndFunctionMetricsAggregator("mean"); + public static final MonitorFormulaAndFunctionMetricsAggregator AREA = + new MonitorFormulaAndFunctionMetricsAggregator("area"); + public static final MonitorFormulaAndFunctionMetricsAggregator L2NORM = + new MonitorFormulaAndFunctionMetricsAggregator("l2norm"); + public static final MonitorFormulaAndFunctionMetricsAggregator PERCENTILE = + new MonitorFormulaAndFunctionMetricsAggregator("percentile"); + public static final MonitorFormulaAndFunctionMetricsAggregator STDDEV = + new MonitorFormulaAndFunctionMetricsAggregator("stddev"); + public static final MonitorFormulaAndFunctionMetricsAggregator COUNT_UNIQUE = + new MonitorFormulaAndFunctionMetricsAggregator("count_unique"); + + MonitorFormulaAndFunctionMetricsAggregator(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionMetricsAggregatorSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionMetricsAggregatorSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionMetricsAggregatorSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionMetricsAggregator value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionMetricsAggregator fromValue(String value) { + return new MonitorFormulaAndFunctionMetricsAggregator(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsDataSource.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsDataSource.java new file mode 100644 index 00000000000..66885408fcd --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsDataSource.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; + +/** Data source for metrics queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionMetricsDataSource + .MonitorFormulaAndFunctionMetricsDataSourceSerializer.class) +public class MonitorFormulaAndFunctionMetricsDataSource extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("metrics", "cloud_cost", "datadog_usage")); + + public static final MonitorFormulaAndFunctionMetricsDataSource METRICS = + new MonitorFormulaAndFunctionMetricsDataSource("metrics"); + public static final MonitorFormulaAndFunctionMetricsDataSource CLOUD_COST = + new MonitorFormulaAndFunctionMetricsDataSource("cloud_cost"); + public static final MonitorFormulaAndFunctionMetricsDataSource DATADOG_USAGE = + new MonitorFormulaAndFunctionMetricsDataSource("datadog_usage"); + + MonitorFormulaAndFunctionMetricsDataSource(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionMetricsDataSourceSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionMetricsDataSourceSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionMetricsDataSourceSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionMetricsDataSource value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionMetricsDataSource fromValue(String value) { + return new MonitorFormulaAndFunctionMetricsDataSource(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsQueryDefinition.java new file mode 100644 index 00000000000..7d474714721 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionMetricsQueryDefinition.java @@ -0,0 +1,189 @@ +/* + * 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.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.Objects; + +/** A formula and functions metrics query for use in aggregate queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionMetricsQueryDefinition.JSON_PROPERTY_AGGREGATOR, + MonitorFormulaAndFunctionMetricsQueryDefinition.JSON_PROPERTY_DATA_SOURCE, + MonitorFormulaAndFunctionMetricsQueryDefinition.JSON_PROPERTY_NAME, + MonitorFormulaAndFunctionMetricsQueryDefinition.JSON_PROPERTY_QUERY +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionMetricsQueryDefinition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_AGGREGATOR = "aggregator"; + private MonitorFormulaAndFunctionMetricsAggregator aggregator; + + public static final String JSON_PROPERTY_DATA_SOURCE = "data_source"; + private MonitorFormulaAndFunctionMetricsDataSource dataSource; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public static final String JSON_PROPERTY_QUERY = "query"; + private String query; + + public MonitorFormulaAndFunctionMetricsQueryDefinition() {} + + @JsonCreator + public MonitorFormulaAndFunctionMetricsQueryDefinition( + @JsonProperty(required = true, value = JSON_PROPERTY_DATA_SOURCE) + MonitorFormulaAndFunctionMetricsDataSource dataSource, + @JsonProperty(required = true, value = JSON_PROPERTY_QUERY) String query) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + this.query = query; + } + + public MonitorFormulaAndFunctionMetricsQueryDefinition aggregator( + MonitorFormulaAndFunctionMetricsAggregator aggregator) { + this.aggregator = aggregator; + this.unparsed |= !aggregator.isValid(); + return this; + } + + /** + * Aggregator for metrics queries. + * + * @return aggregator + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_AGGREGATOR) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorFormulaAndFunctionMetricsAggregator getAggregator() { + return aggregator; + } + + public void setAggregator(MonitorFormulaAndFunctionMetricsAggregator aggregator) { + if (!aggregator.isValid()) { + this.unparsed = true; + } + this.aggregator = aggregator; + } + + public MonitorFormulaAndFunctionMetricsQueryDefinition dataSource( + MonitorFormulaAndFunctionMetricsDataSource dataSource) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + return this; + } + + /** + * Data source for metrics queries. + * + * @return dataSource + */ + @JsonProperty(JSON_PROPERTY_DATA_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionMetricsDataSource getDataSource() { + return dataSource; + } + + public void setDataSource(MonitorFormulaAndFunctionMetricsDataSource dataSource) { + if (!dataSource.isValid()) { + this.unparsed = true; + } + this.dataSource = dataSource; + } + + public MonitorFormulaAndFunctionMetricsQueryDefinition name(String name) { + this.name = name; + return this; + } + + /** + * Name of the query for use in formulas. + * + * @return name + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public MonitorFormulaAndFunctionMetricsQueryDefinition query(String query) { + this.query = query; + return this; + } + + /** + * The metrics query definition. + * + * @return query + */ + @JsonProperty(JSON_PROPERTY_QUERY) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getQuery() { + return query; + } + + public void setQuery(String query) { + this.query = query; + } + + /** Return true if this MonitorFormulaAndFunctionMetricsQueryDefinition object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionMetricsQueryDefinition + monitorFormulaAndFunctionMetricsQueryDefinition = + (MonitorFormulaAndFunctionMetricsQueryDefinition) o; + return Objects.equals( + this.aggregator, monitorFormulaAndFunctionMetricsQueryDefinition.aggregator) + && Objects.equals( + this.dataSource, monitorFormulaAndFunctionMetricsQueryDefinition.dataSource) + && Objects.equals(this.name, monitorFormulaAndFunctionMetricsQueryDefinition.name) + && Objects.equals(this.query, monitorFormulaAndFunctionMetricsQueryDefinition.query); + } + + @Override + public int hashCode() { + return Objects.hash(aggregator, dataSource, name, query); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionMetricsQueryDefinition {\n"); + sb.append(" aggregator: ").append(toIndentedString(aggregator)).append("\n"); + sb.append(" dataSource: ").append(toIndentedString(dataSource)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).append("\n"); + sb.append(" query: ").append(toIndentedString(query)).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 4a0947e341b..140eb085019 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 @@ -249,6 +249,129 @@ public MonitorFormulaAndFunctionQueryDefinition deserialize( e); } + // deserialize MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Boolean.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Integer.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Float.class) + || MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class.equals( + String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.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 (!((MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema" + + " 'MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition'", + e); + } + + // deserialize MonitorFormulaAndFunctionAggregateFilteredQueryDefinition + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals(Integer.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals(Long.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals(Float.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals(Double.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals(Boolean.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + Integer.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + Float.class) + || MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class.equals( + String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.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 (!((MonitorFormulaAndFunctionAggregateFilteredQueryDefinition) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, + "Input data matches schema" + + " 'MonitorFormulaAndFunctionAggregateFilteredQueryDefinition'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema" + + " 'MonitorFormulaAndFunctionAggregateFilteredQueryDefinition'", + e); + } + MonitorFormulaAndFunctionQueryDefinition ret = new MonitorFormulaAndFunctionQueryDefinition(); if (match == 1) { ret.setActualInstance(deserialized); @@ -295,6 +418,18 @@ public MonitorFormulaAndFunctionQueryDefinition( setActualInstance(o); } + public MonitorFormulaAndFunctionQueryDefinition( + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + + public MonitorFormulaAndFunctionQueryDefinition( + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + static { schemas.put( "MonitorFormulaAndFunctionEventQueryDefinition", @@ -305,6 +440,12 @@ public MonitorFormulaAndFunctionQueryDefinition( schemas.put( "MonitorFormulaAndFunctionDataQualityQueryDefinition", new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition", + new GenericType() {}); + schemas.put( + "MonitorFormulaAndFunctionAggregateFilteredQueryDefinition", + new GenericType() {}); JSON.registerDescendants( MonitorFormulaAndFunctionQueryDefinition.class, Collections.unmodifiableMap(schemas)); } @@ -318,7 +459,9 @@ 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, - * MonitorFormulaAndFunctionDataQualityQueryDefinition + * MonitorFormulaAndFunctionDataQualityQueryDefinition, + * MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition, + * MonitorFormulaAndFunctionAggregateFilteredQueryDefinition * *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a * composed schema (allOf, anyOf, oneOf). @@ -342,6 +485,20 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } + if (JSON.isInstanceOf( + MonitorFormulaAndFunctionAggregateFilteredQueryDefinition.class, + instance, + new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -350,17 +507,23 @@ public void setActualInstance(Object instance) { throw new RuntimeException( "Invalid instance type. Must be MonitorFormulaAndFunctionEventQueryDefinition," + " MonitorFormulaAndFunctionCostQueryDefinition," - + " MonitorFormulaAndFunctionDataQualityQueryDefinition"); + + " MonitorFormulaAndFunctionDataQualityQueryDefinition," + + " MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition," + + " MonitorFormulaAndFunctionAggregateFilteredQueryDefinition"); } /** * Get the actual instance, which can be the following: * MonitorFormulaAndFunctionEventQueryDefinition, MonitorFormulaAndFunctionCostQueryDefinition, - * MonitorFormulaAndFunctionDataQualityQueryDefinition + * MonitorFormulaAndFunctionDataQualityQueryDefinition, + * MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition, + * MonitorFormulaAndFunctionAggregateFilteredQueryDefinition * * @return The actual instance (MonitorFormulaAndFunctionEventQueryDefinition, * MonitorFormulaAndFunctionCostQueryDefinition, - * MonitorFormulaAndFunctionDataQualityQueryDefinition) + * MonitorFormulaAndFunctionDataQualityQueryDefinition, + * MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition, + * MonitorFormulaAndFunctionAggregateFilteredQueryDefinition) */ @Override public Object getActualInstance() { @@ -408,4 +571,32 @@ public Object getActualInstance() { getMonitorFormulaAndFunctionDataQualityQueryDefinition() throws ClassCastException { return (MonitorFormulaAndFunctionDataQualityQueryDefinition) super.getActualInstance(); } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition`. If the + * actual instance is not `MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition`, the + * ClassCastException will be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition` + */ + public MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition + getMonitorFormulaAndFunctionAggregateAugmentedQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionAggregateAugmentedQueryDefinition) super.getActualInstance(); + } + + /** + * Get the actual instance of `MonitorFormulaAndFunctionAggregateFilteredQueryDefinition`. If the + * actual instance is not `MonitorFormulaAndFunctionAggregateFilteredQueryDefinition`, the + * ClassCastException will be thrown. + * + * @return The actual instance of `MonitorFormulaAndFunctionAggregateFilteredQueryDefinition` + * @throws ClassCastException if the instance is not + * `MonitorFormulaAndFunctionAggregateFilteredQueryDefinition` + */ + public MonitorFormulaAndFunctionAggregateFilteredQueryDefinition + getMonitorFormulaAndFunctionAggregateFilteredQueryDefinition() throws ClassCastException { + return (MonitorFormulaAndFunctionAggregateFilteredQueryDefinition) super.getActualInstance(); + } } diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableColumn.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableColumn.java new file mode 100644 index 00000000000..fd71aaf7770 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableColumn.java @@ -0,0 +1,119 @@ +/* + * 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.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.Objects; + +/** A column definition for reference table queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionReferenceTableColumn.JSON_PROPERTY_ALIAS, + MonitorFormulaAndFunctionReferenceTableColumn.JSON_PROPERTY_NAME +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionReferenceTableColumn { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ALIAS = "alias"; + private String alias; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public MonitorFormulaAndFunctionReferenceTableColumn() {} + + @JsonCreator + public MonitorFormulaAndFunctionReferenceTableColumn( + @JsonProperty(required = true, value = JSON_PROPERTY_NAME) String name) { + this.name = name; + } + + public MonitorFormulaAndFunctionReferenceTableColumn alias(String alias) { + this.alias = alias; + return this; + } + + /** + * Optional alias for the column. + * + * @return alias + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_ALIAS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getAlias() { + return alias; + } + + public void setAlias(String alias) { + this.alias = alias; + } + + public MonitorFormulaAndFunctionReferenceTableColumn name(String name) { + this.name = name; + return this; + } + + /** + * Name of the column. + * + * @return name + */ + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** Return true if this MonitorFormulaAndFunctionReferenceTableColumn object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionReferenceTableColumn monitorFormulaAndFunctionReferenceTableColumn = + (MonitorFormulaAndFunctionReferenceTableColumn) o; + return Objects.equals(this.alias, monitorFormulaAndFunctionReferenceTableColumn.alias) + && Objects.equals(this.name, monitorFormulaAndFunctionReferenceTableColumn.name); + } + + @Override + public int hashCode() { + return Objects.hash(alias, name); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionReferenceTableColumn {\n"); + sb.append(" alias: ").append(toIndentedString(alias)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).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/MonitorFormulaAndFunctionReferenceTableDataSource.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableDataSource.java new file mode 100644 index 00000000000..f5bea49e952 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableDataSource.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 reference table queries. */ +@JsonSerialize( + using = + MonitorFormulaAndFunctionReferenceTableDataSource + .MonitorFormulaAndFunctionReferenceTableDataSourceSerializer.class) +public class MonitorFormulaAndFunctionReferenceTableDataSource extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("reference_table")); + + public static final MonitorFormulaAndFunctionReferenceTableDataSource REFERENCE_TABLE = + new MonitorFormulaAndFunctionReferenceTableDataSource("reference_table"); + + MonitorFormulaAndFunctionReferenceTableDataSource(String value) { + super(value, allowedValues); + } + + public static class MonitorFormulaAndFunctionReferenceTableDataSourceSerializer + extends StdSerializer { + public MonitorFormulaAndFunctionReferenceTableDataSourceSerializer( + Class t) { + super(t); + } + + public MonitorFormulaAndFunctionReferenceTableDataSourceSerializer() { + this(null); + } + + @Override + public void serialize( + MonitorFormulaAndFunctionReferenceTableDataSource value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static MonitorFormulaAndFunctionReferenceTableDataSource fromValue(String value) { + return new MonitorFormulaAndFunctionReferenceTableDataSource(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableQueryDefinition.java b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableQueryDefinition.java new file mode 100644 index 00000000000..765ff770d74 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v1/model/MonitorFormulaAndFunctionReferenceTableQueryDefinition.java @@ -0,0 +1,232 @@ +/* + * 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.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.List; +import java.util.Objects; + +/** A reference table query for use in aggregate queries. */ +@JsonPropertyOrder({ + MonitorFormulaAndFunctionReferenceTableQueryDefinition.JSON_PROPERTY_COLUMNS, + MonitorFormulaAndFunctionReferenceTableQueryDefinition.JSON_PROPERTY_DATA_SOURCE, + MonitorFormulaAndFunctionReferenceTableQueryDefinition.JSON_PROPERTY_NAME, + MonitorFormulaAndFunctionReferenceTableQueryDefinition.JSON_PROPERTY_QUERY_FILTER, + MonitorFormulaAndFunctionReferenceTableQueryDefinition.JSON_PROPERTY_TABLE_NAME +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorFormulaAndFunctionReferenceTableQueryDefinition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_COLUMNS = "columns"; + private List columns = null; + + public static final String JSON_PROPERTY_DATA_SOURCE = "data_source"; + private MonitorFormulaAndFunctionReferenceTableDataSource dataSource; + + public static final String JSON_PROPERTY_NAME = "name"; + private String name; + + public static final String JSON_PROPERTY_QUERY_FILTER = "query_filter"; + private String queryFilter; + + public static final String JSON_PROPERTY_TABLE_NAME = "table_name"; + private String tableName; + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition() {} + + @JsonCreator + public MonitorFormulaAndFunctionReferenceTableQueryDefinition( + @JsonProperty(required = true, value = JSON_PROPERTY_DATA_SOURCE) + MonitorFormulaAndFunctionReferenceTableDataSource dataSource, + @JsonProperty(required = true, value = JSON_PROPERTY_TABLE_NAME) String tableName) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + this.tableName = tableName; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition columns( + List columns) { + this.columns = columns; + for (MonitorFormulaAndFunctionReferenceTableColumn item : columns) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition addColumnsItem( + MonitorFormulaAndFunctionReferenceTableColumn columnsItem) { + if (this.columns == null) { + this.columns = new ArrayList<>(); + } + this.columns.add(columnsItem); + this.unparsed |= columnsItem.unparsed; + return this; + } + + /** + * List of columns to retrieve from the reference table. + * + * @return columns + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_COLUMNS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getColumns() { + return columns; + } + + public void setColumns(List columns) { + this.columns = columns; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition dataSource( + MonitorFormulaAndFunctionReferenceTableDataSource dataSource) { + this.dataSource = dataSource; + this.unparsed |= !dataSource.isValid(); + return this; + } + + /** + * Data source for reference table queries. + * + * @return dataSource + */ + @JsonProperty(JSON_PROPERTY_DATA_SOURCE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public MonitorFormulaAndFunctionReferenceTableDataSource getDataSource() { + return dataSource; + } + + public void setDataSource(MonitorFormulaAndFunctionReferenceTableDataSource dataSource) { + if (!dataSource.isValid()) { + this.unparsed = true; + } + this.dataSource = dataSource; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition name(String name) { + this.name = name; + return this; + } + + /** + * Name of the query. + * + * @return name + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_NAME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition queryFilter(String queryFilter) { + this.queryFilter = queryFilter; + return this; + } + + /** + * Optional filter expression for the reference table query. + * + * @return queryFilter + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_QUERY_FILTER) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public String getQueryFilter() { + return queryFilter; + } + + public void setQueryFilter(String queryFilter) { + this.queryFilter = queryFilter; + } + + public MonitorFormulaAndFunctionReferenceTableQueryDefinition tableName(String tableName) { + this.tableName = tableName; + return this; + } + + /** + * Name of the reference table. + * + * @return tableName + */ + @JsonProperty(JSON_PROPERTY_TABLE_NAME) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getTableName() { + return tableName; + } + + public void setTableName(String tableName) { + this.tableName = tableName; + } + + /** + * Return true if this MonitorFormulaAndFunctionReferenceTableQueryDefinition object is equal to + * o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorFormulaAndFunctionReferenceTableQueryDefinition + monitorFormulaAndFunctionReferenceTableQueryDefinition = + (MonitorFormulaAndFunctionReferenceTableQueryDefinition) o; + return Objects.equals( + this.columns, monitorFormulaAndFunctionReferenceTableQueryDefinition.columns) + && Objects.equals( + this.dataSource, monitorFormulaAndFunctionReferenceTableQueryDefinition.dataSource) + && Objects.equals(this.name, monitorFormulaAndFunctionReferenceTableQueryDefinition.name) + && Objects.equals( + this.queryFilter, monitorFormulaAndFunctionReferenceTableQueryDefinition.queryFilter) + && Objects.equals( + this.tableName, monitorFormulaAndFunctionReferenceTableQueryDefinition.tableName); + } + + @Override + public int hashCode() { + return Objects.hash(columns, dataSource, name, queryFilter, tableName); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorFormulaAndFunctionReferenceTableQueryDefinition {\n"); + sb.append(" columns: ").append(toIndentedString(columns)).append("\n"); + sb.append(" dataSource: ").append(toIndentedString(dataSource)).append("\n"); + sb.append(" name: ").append(toIndentedString(name)).append("\n"); + sb.append(" queryFilter: ").append(toIndentedString(queryFilter)).append("\n"); + sb.append(" tableName: ").append(toIndentedString(tableName)).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/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.freeze b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.freeze new file mode 100644 index 00000000000..db745b4fe76 --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.freeze @@ -0,0 +1 @@ +2026-03-04T20:59:52.837Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.json b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.json new file mode 100644 index 00000000000..2788b3fbf5e --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response.json @@ -0,0 +1,58 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"message\": \"test message\", \"name\": \"Test-Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response-1772657992\", \"options\": {\"thresholds\": {\"critical\": 124}, \"variables\": [{\"augment_query\": {\"columns\": [{\"name\": \"org_id\"}, {\"name\": \"name\"}], \"data_source\": \"reference_table\", \"name\": \"filter_query\", \"table_name\": \"test_table\"}, \"base_query\": {\"data_source\": \"metrics\", \"name\": \"query1\", \"query\": \"avg:dd{*} by {org_id}.as_count()\"}, \"compute\": [{\"aggregation\": \"max\", \"name\": \"compute_result\"}], \"data_source\": \"aggregate_augmented_query\", \"group_by\": [{\"facet\": \"org_id\"}, {\"facet\": \"name\"}], \"join_condition\": {\"augment_attribute\": \"org_id\", \"base_attribute\": \"org_id\", \"join_type\": \"inner\"}, \"name\": \"query1\"}]}, \"query\": \"formula(\\\"query1\\\").rollup(\\\"sum\\\").last(\\\"5m\\\") > 124\", \"type\": \"query alert\"}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v1/monitor", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"id\":263469923,\"org_id\":321813,\"type\":\"metric alert\",\"name\":\"Test-Create_a_monitor_with_aggregate_augmented_query_variables_returns_OK_response-1772657992\",\"message\":\"test message\",\"tags\":[],\"query\":\"formula(\\\"query1\\\").rollup(\\\"sum\\\").last(\\\"5m\\\") > 124\",\"options\":{\"thresholds\":{\"critical\":124.0},\"variables\":[{\"augment_query\":{\"columns\":[{\"name\":\"org_id\"},{\"name\":\"name\"}],\"data_source\":\"reference_table\",\"name\":\"filter_query\",\"table_name\":\"test_table\"},\"base_query\":{\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:dd{*} by {org_id}.as_count()\"},\"compute\":[{\"aggregation\":\"max\",\"name\":\"compute_result\"}],\"data_source\":\"aggregate_augmented_query\",\"group_by\":[{\"facet\":\"org_id\"},{\"facet\":\"name\"}],\"join_condition\":{\"augment_attribute\":\"org_id\",\"base_attribute\":\"org_id\",\"join_type\":\"inner\"},\"name\":\"query1\"}],\"notify_no_data\":false,\"notify_audit\":false,\"new_host_delay\":300,\"include_tags\":true,\"silenced\":{}},\"multi\":false,\"created_at\":1772657993000,\"created\":\"2026-03-04T20:59:53.048028+00:00\",\"modified\":\"2026-03-04T20:59:53.048028+00:00\",\"deleted\":null,\"priority\":null,\"restricted_roles\":null,\"restriction_policy\":null,\"draft_status\":\"published\",\"assets\":[],\"overall_state_modified\":null,\"overall_state\":\"No Data\",\"creator\":{\"name\":\"frog\",\"handle\":\"frog@datadoghq.com\",\"email\":\"frog@datadoghq.com\",\"id\":1445416}}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "605e5c19-4b77-5874-b0cc-0324c89a0085" + }, + { + "httpRequest": { + "headers": {}, + "method": "DELETE", + "path": "/api/v1/monitor/263469923", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"deleted_monitor_id\":263469923}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "fdfaca29-3764-b8dd-c779-812d2da4f221" + } +] \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.freeze b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.freeze new file mode 100644 index 00000000000..4e8c8fe3115 --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.freeze @@ -0,0 +1 @@ +2026-03-03T19:33:24.886Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.json b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.json new file mode 100644 index 00000000000..3fee914e4c1 --- /dev/null +++ b/src/test/resources/cassettes/features/v1/Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response.json @@ -0,0 +1,58 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"message\": \"test message\", \"name\": \"Test-Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response-1772566404\", \"options\": {\"thresholds\": {\"critical\": 100}, \"variables\": [{\"base_query\": {\"data_source\": \"metrics\", \"name\": \"query1\", \"query\": \"max:container.cpu.usage{*} by {kube_cluster_name}.rollup(max)\"}, \"data_source\": \"aggregate_filtered_query\", \"filter_query\": {\"columns\": [{\"name\": \"cluster_name\"}], \"data_source\": \"reference_table\", \"name\": \"filter_query\", \"table_name\": \"test_table\"}, \"filters\": [{\"base_attribute\": \"kube_cluster_name\", \"filter_attribute\": \"cluster_name\"}], \"name\": \"query1\"}]}, \"query\": \"formula(\\\"query1\\\").rollup(\\\"sum\\\").last(\\\"5m\\\") > 100\", \"type\": \"query alert\"}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v1/monitor", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"id\":263171329,\"org_id\":321813,\"type\":\"metric alert\",\"name\":\"Test-Create_a_monitor_with_aggregate_filtered_query_variables_returns_OK_response-1772566404\",\"message\":\"test message\",\"tags\":[],\"query\":\"formula(\\\"query1\\\").rollup(\\\"sum\\\").last(\\\"5m\\\") > 100\",\"options\":{\"thresholds\":{\"critical\":100.0},\"variables\":[{\"base_query\":{\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"max:container.cpu.usage{*} by {kube_cluster_name}.rollup(max)\"},\"data_source\":\"aggregate_filtered_query\",\"filter_query\":{\"columns\":[{\"name\":\"cluster_name\"}],\"data_source\":\"reference_table\",\"name\":\"filter_query\",\"table_name\":\"test_table\"},\"filters\":[{\"base_attribute\":\"kube_cluster_name\",\"filter_attribute\":\"cluster_name\"}],\"name\":\"query1\"}],\"notify_no_data\":false,\"notify_audit\":false,\"new_host_delay\":300,\"include_tags\":true,\"silenced\":{}},\"multi\":false,\"created_at\":1772566405000,\"created\":\"2026-03-03T19:33:25.076678+00:00\",\"modified\":\"2026-03-03T19:33:25.076678+00:00\",\"deleted\":null,\"priority\":null,\"restricted_roles\":null,\"restriction_policy\":null,\"draft_status\":\"published\",\"assets\":[],\"overall_state_modified\":null,\"overall_state\":\"No Data\",\"creator\":{\"name\":\"frog\",\"handle\":\"frog@datadoghq.com\",\"email\":\"frog@datadoghq.com\",\"id\":1445416}}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "d0d50ad1-78ce-e036-d577-934cd065ce24" + }, + { + "httpRequest": { + "headers": {}, + "method": "DELETE", + "path": "/api/v1/monitor/263171329", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"deleted_monitor_id\":263171329}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "565dee88-971c-492c-e9d9-66d348c29c0c" + } +] \ 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 af8d4522e9b..63bb9f16b9a 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 @@ -140,6 +140,26 @@ Feature: Monitors And the response "type" is equal to "log alert" And the response "query" is equal to "logs(\"service:foo AND type:error\").index(\"main\").rollup(\"count\").by(\"source\").last(\"5m\") > 2" + @team:DataDog/monitor-app + Scenario: Create a monitor with aggregate augmented query variables returns "OK" response + Given new "CreateMonitor" request + And body with value {"name":"{{ unique }}","type":"query alert","query":"formula(\"query1\").rollup(\"sum\").last(\"5m\") > 124","message":"test message","options":{"thresholds":{"critical":124},"variables":[{"data_source":"aggregate_augmented_query","name":"query1","group_by":[{"facet":"org_id"},{"facet":"name"}],"compute":[{"name":"compute_result","aggregation":"max"}],"augment_query":{"name":"filter_query","data_source":"reference_table","table_name":"test_table","columns":[{"name":"org_id"},{"name":"name"}]},"base_query":{"data_source":"metrics","name":"query1","query":"avg:dd{*} by {org_id}.as_count()"},"join_condition":{"augment_attribute":"org_id","base_attribute":"org_id","join_type":"inner"}}]}} + When the request is sent + Then the response status is 200 OK + And the response "name" is equal to "{{ unique }}" + And the response "options.variables[0].data_source" is equal to "aggregate_augmented_query" + And the response "options.variables[0].join_condition.join_type" is equal to "inner" + + @team:DataDog/monitor-app + Scenario: Create a monitor with aggregate filtered query variables returns "OK" response + Given new "CreateMonitor" request + And body with value {"name":"{{ unique }}","type":"query alert","query":"formula(\"query1\").rollup(\"sum\").last(\"5m\") > 100","message":"test message","options":{"thresholds":{"critical":100},"variables":[{"data_source":"aggregate_filtered_query","name":"query1","base_query":{"data_source":"metrics","name":"query1","query":"max:container.cpu.usage{*} by {kube_cluster_name}.rollup(max)"},"filter_query":{"name":"filter_query","data_source":"reference_table","table_name":"test_table","columns":[{"name":"cluster_name"}]},"filters":[{"base_attribute":"kube_cluster_name","filter_attribute":"cluster_name"}]}]}} + When the request is sent + Then the response status is 200 OK + And the response "name" is equal to "{{ unique }}" + And the response "options.variables[0].data_source" is equal to "aggregate_filtered_query" + And the response "options.variables[0].filters[0].base_attribute" is equal to "kube_cluster_name" + @team:DataDog/monitor-app Scenario: Create a monitor with assets returns "OK" response Given new "CreateMonitor" request @@ -190,7 +210,7 @@ Feature: Monitors Scenario: Edit a monitor returns "Bad Request" response Given new "UpdateMonitor" request And request contains "monitor_id" parameter from "REPLACE.ME" - And body with value {"assets": [{"category": "runbook", "name": "Monitor Runbook", "resource_key": "12345", "resource_type": "notebook", "url": "/notebooks/12345"}], "draft_status": "published", "options": {"evaluation_delay": null, "include_tags": true, "min_failure_duration": 0, "min_location_failed": 1, "new_group_delay": null, "new_host_delay": 300, "no_data_timeframe": null, "notification_preset_name": "show_all", "notify_audit": false, "notify_by": [], "on_missing_data": "default", "renotify_interval": null, "renotify_occurrences": null, "renotify_statuses": ["alert"], "scheduling_options": {"custom_schedule": {"recurrences": [{"rrule": "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR", "start": "2023-08-31T16:30:00", "timezone": "Europe/Paris"}]}, "evaluation_window": {"day_starts": "04:00", "hour_starts": 0, "month_starts": 1, "timezone": "Europe/Paris"}}, "synthetics_check_id": null, "threshold_windows": {"recovery_window": null, "trigger_window": null}, "thresholds": {"critical_recovery": null, "ok": null, "unknown": null, "warning": null, "warning_recovery": null}, "timeout_h": null, "variables": [{"compute": {"aggregation": "avg", "interval": 60000, "metric": "@duration"}, "data_source": "rum", "group_by": [{"facet": "status", "limit": 10, "sort": {"aggregation": "avg", "order": "desc"}}], "indexes": ["days-3", "days-7"], "name": "query_errors", "search": {"query": "service:query"}}]}, "priority": null, "restricted_roles": [], "tags": [], "type": "query alert"} + And body with value {"assets": [{"category": "runbook", "name": "Monitor Runbook", "resource_key": "12345", "resource_type": "notebook", "url": "/notebooks/12345"}], "draft_status": "published", "options": {"evaluation_delay": null, "include_tags": true, "min_failure_duration": 0, "min_location_failed": 1, "new_group_delay": null, "new_host_delay": 300, "no_data_timeframe": null, "notification_preset_name": "show_all", "notify_audit": false, "notify_by": [], "on_missing_data": "default", "renotify_interval": null, "renotify_occurrences": null, "renotify_statuses": ["alert"], "scheduling_options": {"custom_schedule": {"recurrences": [{"rrule": "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR", "start": "2023-08-31T16:30:00", "timezone": "Europe/Paris"}]}, "evaluation_window": {"day_starts": "04:00", "hour_starts": 0, "month_starts": 1, "timezone": "Europe/Paris"}}, "synthetics_check_id": null, "threshold_windows": {"recovery_window": null, "trigger_window": null}, "thresholds": {"critical_recovery": null, "ok": null, "unknown": null, "warning": null, "warning_recovery": null}, "timeout_h": null, "variables": [{"compute": {"aggregation": "avg", "interval": 60000, "metric": "@duration", "name": "compute_result"}, "data_source": "rum", "group_by": [{"facet": "status", "limit": 10, "sort": {"aggregation": "avg", "order": "desc"}}], "indexes": ["days-3", "days-7"], "name": "query_errors", "search": {"query": "service:query"}}]}, "priority": null, "restricted_roles": [], "tags": [], "type": "query alert"} When the request is sent Then the response status is 400 Bad Request