Mark shard failures caused by unsupported aggregations or queries against rolled up data so Kibana can identify them

server/src/main/java/org/elasticsearch/ElasticsearchException.java

@@ -1578,6 +1578,12 @@ private enum ElasticsearchExceptionHandle {
             HealthNodeNotDiscoveredException::new,
             166,
             Version.V_8_5_0
+        ),
+        UNSUPPORTED_AGGREGATION_ON_DOWNSAMPLED_FIELD_EXCEPTION(
+            org.elasticsearch.search.aggregations.UnsupportedAggregationOnDownsampledField.class,
+            org.elasticsearch.search.aggregations.UnsupportedAggregationOnDownsampledField::new,
+            167,
+            Version.V_8_5_0
         );
 
         final Class<? extends ElasticsearchException> exceptionClass;

server/src/main/java/org/elasticsearch/cluster/metadata/IndexMetadata.java

@@ -22,6 +22,7 @@
 import org.elasticsearch.cluster.routing.allocation.IndexMetadataUpdater;
 import org.elasticsearch.cluster.routing.allocation.decider.DiskThresholdDecider;
 import org.elasticsearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
 import org.elasticsearch.common.collect.MapBuilder;
 import org.elasticsearch.common.compress.CompressedXContent;
@@ -127,6 +128,15 @@ public class IndexMetadata implements Diffable<IndexMetadata>, ToXContentFragmen
         EnumSet.of(ClusterBlockLevel.WRITE)
     );
 
+    public boolean isRollupIndex() {
+        final String sourceIndex = settings.get(IndexMetadata.INDEX_ROLLUP_SOURCE_NAME_KEY);
+        final String indexRollupStatus = settings.get(IndexMetadata.INDEX_ROLLUP_STATUS_KEY);
+        final boolean rollupSuccess = IndexMetadata.RollupTaskStatus.SUCCESS.name()
+            .toLowerCase(Locale.ROOT)
+            .equals(indexRollupStatus != null ? indexRollupStatus.toLowerCase(Locale.ROOT) : IndexMetadata.RollupTaskStatus.UNKNOWN);
+        return Strings.isNullOrEmpty(sourceIndex) == false && rollupSuccess;
+    }
+
     public enum State implements Writeable {
         OPEN((byte) 0),
         CLOSE((byte) 1);

server/src/main/java/org/elasticsearch/index/IndexMode.java

@@ -11,6 +11,7 @@
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.MetadataCreateDataStreamService;
 import org.elasticsearch.cluster.routing.IndexRouting;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.compress.CompressedXContent;
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Settings;
@@ -28,10 +29,13 @@
 import org.elasticsearch.index.mapper.RoutingFieldMapper;
 import org.elasticsearch.index.mapper.TimeSeriesIdFieldMapper;
 import org.elasticsearch.index.mapper.TsidExtractingIdFieldMapper;
+import org.elasticsearch.search.aggregations.bucket.histogram.DateIntervalWrapper;
 
 import java.io.IOException;
+import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.BooleanSupplier;
@@ -110,6 +114,22 @@ public DocumentDimensions buildDocumentDimensions(IndexSettings settings) {
         public boolean shouldValidateTimestamp() {
             return false;
         }
+
+        @Override
+        public void validateCalendarIntervalType(
+            IndexSettings indexSettings,
+            DateIntervalWrapper.IntervalTypeEnum intervalType,
+            String valuesSourceDescription,
+            String aggregationName
+        ) {}
+
+        @Override
+        public void validateCalendarTimeZone(
+            IndexSettings indexSettings,
+            ZoneId tz,
+            String valuesSourceDescription,
+            String aggregationName
+        ) {}
     },
     TIME_SERIES("time_series") {
         @Override
@@ -196,8 +216,55 @@ public DocumentDimensions buildDocumentDimensions(IndexSettings settings) {
         public boolean shouldValidateTimestamp() {
             return true;
         }
+
+        /**
+         * For a time series index we just support 'fixed_interval' aggregations.
+         *
+         * @param intervalType the type of interval used by the date histogram
+         */
+        @Override
+        public void validateCalendarIntervalType(
+            IndexSettings indexSettings,
+            DateIntervalWrapper.IntervalTypeEnum intervalType,
+            String valuesSourceDescription,
+            String aggregationName
+        ) {
+            if (indexSettings.getIndexMetadata().isRollupIndex() && DateIntervalWrapper.IntervalTypeEnum.CALENDAR.equals(intervalType)) {
+                throw new IllegalArgumentException(
+                    valuesSourceDescription
+                        + " is not supported for aggregation ["
+                        + aggregationName
+                        + "] with interval type ["
+                        + intervalType.getPreferredName()
+                        + "]"
+                );
+            }
+        }
+
+        @Override
+        public void validateCalendarTimeZone(
+            IndexSettings indexSettings,
+            ZoneId tz,
+            String valuesSourceDescription,
+            String aggregationName
+        ) {
+            if (indexSettings.getIndexMetadata().isRollupIndex() && tz != null && ZoneId.of("UTC").equals(tz) == false) {
+                throw new IllegalArgumentException(
+                    valuesSourceDescription + " is not supported for aggregation [" + aggregationName + "] with timezone [" + tz + "]"
+                );
+            }
+        }
     };
 
+    private static boolean isIndexRollup(final IndexSettings indexSettings) {
+        final String sourceIndex = indexSettings.getIndexMetadata().getSettings().get(IndexMetadata.INDEX_ROLLUP_SOURCE_NAME_KEY);
+        final String indexRollupStatus = indexSettings.getIndexMetadata().getSettings().get(IndexMetadata.INDEX_ROLLUP_STATUS_KEY);
+        final boolean rollupSuccess = IndexMetadata.RollupTaskStatus.SUCCESS.name()
+            .toLowerCase(Locale.ROOT)
+            .equals(indexRollupStatus != null ? indexRollupStatus.toLowerCase(Locale.ROOT) : IndexMetadata.RollupTaskStatus.UNKNOWN);
+        return Strings.isNullOrEmpty(sourceIndex) == false && rollupSuccess;
+    }
+
     protected static String tsdbMode() {
         return "[" + IndexSettings.MODE.getKey() + "=time_series]";
     }
@@ -331,4 +398,18 @@ public static IndexMode fromString(String value) {
     public String toString() {
         return getName();
     }
+
+    public abstract void validateCalendarIntervalType(
+        IndexSettings indexSettings,
+        DateIntervalWrapper.IntervalTypeEnum intervalType,
+        String valuesSourceDescription,
+        String aggregationName
+    );
+
+    public abstract void validateCalendarTimeZone(
+        IndexSettings indexSettings,
+        ZoneId tz,
+        String valueSourceDescription,
+        String aggregationName
+    );
 }

server/src/main/java/org/elasticsearch/search/aggregations/UnsupportedAggregationOnDownsampledField.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.search.aggregations;
+
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.rest.RestStatus;
+
+import java.io.IOException;
+
+/**
+ * Thrown when executing an aggregation on a time series index field whose type is not supported.
+ * Downsampling uses specific types while aggregating some fields (like 'aggregate_metric_double').
+ * Such field types do not support some aggregations.
+ */
+public class UnsupportedAggregationOnDownsampledField extends AggregationExecutionException {
+
+    public UnsupportedAggregationOnDownsampledField(final String msg) {
+        super(msg);
+    }
+
+    public UnsupportedAggregationOnDownsampledField(final StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public RestStatus status() {
+        return RestStatus.BAD_REQUEST;
+    }
+}

server/src/main/java/org/elasticsearch/search/aggregations/bucket/histogram/DateHistogramAggregationBuilder.java

@@ -417,9 +417,16 @@ protected ValuesSourceAggregatorFactory innerBuild(
         AggregatorFactory parent,
         AggregatorFactories.Builder subFactoriesBuilder
     ) throws IOException {
-        DateHistogramAggregationSupplier aggregatorSupplier = context.getValuesSourceRegistry().getAggregator(REGISTRY_KEY, config);
+        final DateIntervalWrapper.IntervalTypeEnum dateHistogramIntervalType = dateHistogramInterval.getIntervalType();
+
+        context.getIndexSettings()
+            .getMode()
+            .validateCalendarIntervalType(context.getIndexSettings(), dateHistogramIntervalType, config.getDescription(), getName());
 
         final ZoneId tz = timeZone();
+        context.getIndexSettings().getMode().validateCalendarTimeZone(context.getIndexSettings(), tz, config.getDescription(), getName());
+
+        DateHistogramAggregationSupplier aggregatorSupplier = context.getValuesSourceRegistry().getAggregator(REGISTRY_KEY, config);
         final Rounding rounding = dateHistogramInterval.createRounding(tz, offset);
 
         LongBounds roundedBounds = null;

server/src/main/java/org/elasticsearch/search/aggregations/support/ValuesSourceRegistry.java

@@ -169,13 +169,23 @@ public <T> T getAggregator(RegistryKey<T> registryKey, ValuesSourceConfig values
             @SuppressWarnings("unchecked")
             T supplier = (T) aggregatorRegistry.get(registryKey).get(valuesSourceConfig.valueSourceType());
             if (supplier == null) {
-                throw new IllegalArgumentException(
-                    valuesSourceConfig.getDescription() + " is not supported for aggregation [" + registryKey.getName() + "]"
-                );
+                final RuntimeException unmappedException = valuesSourceConfig.valueSourceType()
+                    .getUnregisteredException(
+                        valuesSourceConfig.getDescription() + " is not supported for aggregation [" + registryKey.getName() + "]"
+                    );
+                assert unmappedException != null
+                    : "Value source type ["
+                        + valuesSourceConfig.valueSourceType()
+                        + "] did not return a valid exception for aggregation ["
+                        + registryKey.getName()
+                        + "]";
+                throw unmappedException;
             }
             return supplier;
         }
-        throw new AggregationExecutionException("Unregistered Aggregation [" + registryKey.getName() + "]");
+        throw new AggregationExecutionException(
+            "Unregistered Aggregation [" + (registryKey != null ? registryKey.getName() : "unknown aggregation") + "]"
+        );
     }
 
     public AggregationUsageService getUsageService() {

server/src/main/java/org/elasticsearch/search/aggregations/support/ValuesSourceType.java

@@ -92,4 +92,15 @@ default DocValueFormat getFormatter(String format, ZoneId tz) {
      * @return the name of the Values Source Type
      */
     String typeName();
+
+    /**
+     * Returns the exception to throw in case the registry (type, aggregator) entry
+     * is not registered.
+     *
+     * @param message the message for the exception
+     * @return the exception to throw
+     */
+    default RuntimeException getUnregisteredException(String message) {
+        return new IllegalArgumentException(message);
+    }
 }

server/src/test/java/org/elasticsearch/ExceptionSerializationTests.java

@@ -73,6 +73,7 @@
 import org.elasticsearch.search.SearchParseException;
 import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.aggregations.MultiBucketConsumerService;
+import org.elasticsearch.search.aggregations.UnsupportedAggregationOnDownsampledField;
 import org.elasticsearch.search.internal.ShardSearchContextId;
 import org.elasticsearch.snapshots.Snapshot;
 import org.elasticsearch.snapshots.SnapshotException;
@@ -831,6 +832,7 @@ public void testIds() {
         ids.put(164, VersionConflictException.class);
         ids.put(165, SnapshotNameAlreadyInUseException.class);
         ids.put(166, HealthNodeNotDiscoveredException.class);
+        ids.put(167, UnsupportedAggregationOnDownsampledField.class);
 
         Map<Class<? extends ElasticsearchException>, Integer> reverse = new HashMap<>();
         for (Map.Entry<Integer, Class<? extends ElasticsearchException>> entry : ids.entrySet()) {

x-pack/plugin/mapper-aggregate-metric/src/main/java/org/elasticsearch/xpack/aggregatemetric/aggregations/support/AggregateMetricsValuesSourceType.java

@@ -10,6 +10,7 @@
 import org.elasticsearch.script.AggregationScript;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.aggregations.AggregationExecutionException;
+import org.elasticsearch.search.aggregations.UnsupportedAggregationOnDownsampledField;
 import org.elasticsearch.search.aggregations.support.AggregationContext;
 import org.elasticsearch.search.aggregations.support.FieldContext;
 import org.elasticsearch.search.aggregations.support.ValueType;
@@ -22,6 +23,12 @@
 public enum AggregateMetricsValuesSourceType implements ValuesSourceType {
 
     AGGREGATE_METRIC() {
+
+        @Override
+        public RuntimeException getUnregisteredException(String message) {
+            return new UnsupportedAggregationOnDownsampledField(message);
+        }
+
         @Override
         public ValuesSource getEmpty() {
             throw new IllegalArgumentException("Can't deal with unmapped AggregateMetricsValuesSource type " + this.value());