[8.9] [Lens] Improve message for unsupported aggregation when using a TSDB counter field (#161481) (#164144)

# Backport This will backport the following commits from `main` to `8.9`: - [[Lens] Improve message for unsupported aggregation when using a TSDB counter field (#161481)](https://github.com/elastic/kibana/pull/161481)  ### Questions ? Please refer to the [Backport tool documentation](https://github.com/sqren/backport)
2025-04-24 01:38:56 -04:00 · 2023-08-17 14:53:45 +02:00 · 2023-08-17 14:53:45 +02:00 · b63845506e
commit b63845506e
parent 876d341bf3
7 changed files with 190 additions and 33 deletions
--- a/packages/kbn-doc-links/src/get_doc_links.ts
+++ b/packages/kbn-doc-links/src/get_doc_links.ts
@ -715,6 +715,8 @@ export const getDocLinks = ({ kibanaBranch }: GetDocLinkOptions): DocLinks => {
      datastreamsILM: `${FLEET_DOCS}data-streams.html#data-streams-ilm`,
      datastreamsNamingScheme: `${FLEET_DOCS}data-streams.html#data-streams-naming-scheme`,
      datastreamsManualRollover: `${ELASTICSEARCH_DOCS}use-a-data-stream.html#manually-roll-over-a-data-stream`,
+      datastreamsTSDS: `${ELASTICSEARCH_DOCS}tsds.html`,
+      datastreamsTSDSMetrics: `${ELASTICSEARCH_DOCS}tsds.html#time-series-metric`,
      installElasticAgent: `${FLEET_DOCS}install-fleet-managed-elastic-agent.html`,
      installElasticAgentStandalone: `${FLEET_DOCS}install-standalone-elastic-agent.html`,
      upgradeElasticAgent: `${FLEET_DOCS}upgrade-elastic-agent.html`,
--- a/packages/kbn-doc-links/src/types.ts
+++ b/packages/kbn-doc-links/src/types.ts
@ -483,6 +483,8 @@ export interface DocLinks {
    datastreamsILM: string;
    datastreamsNamingScheme: string;
    datastreamsManualRollover: string;
+    datastreamsTSDS: string;
+    datastreamsTSDSMetrics: string;
    installElasticAgent: string;
    installElasticAgentStandalone: string;
    packageSignatures: string;
--- a/x-pack/plugins/lens/public/editor_frame_service/editor_frame/workspace_panel/workspace_panel.tsx
+++ b/x-pack/plugins/lens/public/editor_frame_service/editor_frame/workspace_panel/workspace_panel.tsx
@ -788,9 +788,9 @@ export const VisualizationWrapper = ({
        executionContext={executionContext}
        renderMode="edit"
        renderError={(errorMessage?: string | null, error?: ExpressionRenderError | null) => {
-          const errorsFromRequest = getOriginalRequestErrorMessages(error);
+          const errorsFromRequest = getOriginalRequestErrorMessages(error || null, core.docLinks);
          const visibleErrorMessages = errorsFromRequest.length
-            ? errorsFromRequest
+            ? errorsFromRequest.map((e) => e.longMessage || e.shortMessage)
            : errorMessage
            ? [errorMessage]
            : [];
@ -829,11 +829,15 @@ export const VisualizationWrapper = ({
                      </p>

                      {localState.expandError
-                        ? visibleErrorMessages.map((visibleErrorMessage) => (
-                            <p className="eui-textBreakWord" key={visibleErrorMessage}>
-                              {visibleErrorMessage}
-                            </p>
-                          ))
+                        ? visibleErrorMessages.map((visibleErrorMessage) =>
+                            typeof visibleErrorMessage === 'string' ? (
+                              <p className="eui-textBreakWord" key={visibleErrorMessage}>
+                                {visibleErrorMessage}
+                              </p>
+                            ) : (
+                              visibleErrorMessage
+                            )
+                          )
                        : null}
                    </>
                  }
--- a/x-pack/plugins/lens/public/editor_frame_service/error_helper.test.ts
+++ b/x-pack/plugins/lens/public/editor_frame_service/error_helper.test.ts
@ -6,6 +6,9 @@
 */

 import { getOriginalRequestErrorMessages } from './error_helper';
+import type { CoreStart } from '@kbn/core/public';
+
+const docLinksMock = { links: { fleet: { datastreamsTSDSMetrics: '' } } } as CoreStart['docLinks'];

 const runtimeFieldError = {
  stack: 'Error: EsError\n...',
@ -163,33 +166,136 @@ const indexpatternAccessError = {
  },
 };

+const tsdbCounterUsedWithWrongOperationError = {
+  stack:
+    'Error: EsError: Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+  message:
+    '[layeredXyVis] > [esaggs] > EsError: Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+  name: 'Error',
+  original: {
+    attributes: {
+      type: 'status_exception',
+      reason: 'error while executing search',
+      caused_by: {
+        type: 'search_phase_execution_exception',
+        reason: 'all shards failed',
+        phase: 'query',
+        grouped: true,
+        failed_shards: [
+          {
+            shard: 0,
+            index: 'tsdb_index',
+            reason: {
+              type: 'illegal_argument_exception',
+              reason:
+                'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+            },
+          },
+        ],
+        caused_by: {
+          type: 'illegal_argument_exception',
+          reason:
+            'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+          caused_by: {
+            type: 'illegal_argument_exception',
+            reason:
+              'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+          },
+        },
+      },
+    },
+    err: {
+      message:
+        'status_exception\n\tCaused by:\n\t\tsearch_phase_execution_exception: all shards failed',
+      statusCode: 400,
+      attributes: {
+        type: 'status_exception',
+        reason: 'error while executing search',
+        caused_by: {
+          type: 'search_phase_execution_exception',
+          reason: 'all shards failed',
+          phase: 'query',
+          grouped: true,
+          failed_shards: [
+            {
+              shard: 0,
+              index: 'tsdb_index',
+              reason: {
+                type: 'illegal_argument_exception',
+                reason:
+                  'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+              },
+            },
+          ],
+          caused_by: {
+            type: 'illegal_argument_exception',
+            reason:
+              'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+            caused_by: {
+              type: 'illegal_argument_exception',
+              reason:
+                'Field [bytes_counter] of type [long][counter] is not supported for aggregation [sum]',
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
 describe('lens_error_helpers', () => {
  describe('getOriginalRequestErrorMessages', () => {
    it('should report no errors if not parsable', () => {
-      expect(getOriginalRequestErrorMessages(null)).toEqual([]);
+      expect(getOriginalRequestErrorMessages(null, docLinksMock)).toEqual([]);
    });

    it('should report an error for a runtime field error', () => {
-      expect(getOriginalRequestErrorMessages(runtimeFieldError)).toEqual([
-        'Request error: number_format_exception, For input string: "hello" in "emit(Integer.parseInt(\'hello\'))" (Painless script)',
+      expect(getOriginalRequestErrorMessages(runtimeFieldError, docLinksMock)).toEqual([
+        expect.objectContaining({
+          shortMessage:
+            'Request error: number_format_exception, For input string: "hello" in "emit(Integer.parseInt(\'hello\'))" (Painless script)',
+        }),
      ]);
    });

    it('should report an error for a scripted field error', () => {
-      expect(getOriginalRequestErrorMessages(scriptedFieldError)).toEqual([
-        'Request error: aggregation_execution_exception, Unsupported script value [hello], expected a number, date, or boolean in Painless script',
+      expect(getOriginalRequestErrorMessages(scriptedFieldError, docLinksMock)).toEqual([
+        expect.objectContaining({
+          shortMessage:
+            'Request error: aggregation_execution_exception, Unsupported script value [hello], expected a number, date, or boolean in Painless script',
+        }),
      ]);
    });

    it('should report the original es aggs error for runtime fields for indexpattern not accessible', () => {
-      expect(getOriginalRequestErrorMessages(indexpatternAccessError as Error)).toEqual([
-        indexpatternAccessError.message,
+      expect(
+        getOriginalRequestErrorMessages(indexpatternAccessError as Error, docLinksMock)
+      ).toEqual([
+        expect.objectContaining({
+          shortMessage: indexpatternAccessError.message,
+        }),
      ]);
    });

    it("should report a network custom message when there's a network/connection problem", () => {
-      expect(getOriginalRequestErrorMessages(networkError as Error)).toEqual([
-        'Network error, try again later or contact your administrator.',
+      expect(getOriginalRequestErrorMessages(networkError as Error, docLinksMock)).toEqual([
+        expect.objectContaining({
+          shortMessage: 'Network error, try again later or contact your administrator.',
+        }),
+      ]);
+    });
+
+    it('should report two specific errors in case of an unsupported operation applied to a TSDB counter', () => {
+      expect(
+        getOriginalRequestErrorMessages(
+          tsdbCounterUsedWithWrongOperationError as Error,
+          docLinksMock
+        )
+      ).toEqual([
+        expect.objectContaining({
+          shortMessage:
+            'The field [bytes_counter] of Time series type [counter] has been used with the unsupported operation [sum].',
+        }),
      ]);
    });
  });
--- a/x-pack/plugins/lens/public/editor_frame_service/error_helper.tsx
+++ b/x-pack/plugins/lens/public/editor_frame_service/error_helper.tsx
@ -8,8 +8,12 @@
 import { i18n } from '@kbn/i18n';
 import { isEqual, uniqWith } from 'lodash';
 import { ExpressionRenderError } from '@kbn/expressions-plugin/public';
+import type { CoreStart } from '@kbn/core/public';
 import { isEsError } from '@kbn/data-plugin/public';
 import type { IEsError, Reason } from '@kbn/data-plugin/public';
+import React from 'react';
+import { EuiLink } from '@elastic/eui';
+import { RemovableUserMessage } from '../types';

 type ErrorCause = Required<IEsError>['attributes'];

@ -39,6 +43,13 @@ const isRequestError = (e: Error | RequestError): e is RequestError => {
  return false;
 };

+const isTSDBError = (e: ReasonDescription): boolean => {
+  return (
+    e.type === 'illegal_argument_exception' &&
+    /\]\[counter\] is not supported for aggregation/.test(e.reason)
+  );
+};
+
 // what happens for runtime field used on indexpatterns not accessible to the user?
 // they will throw on the kibana side as data will be undefined
 const isEsAggError = (e: Error | EsAggError): e is EsAggError => {
@ -101,8 +112,11 @@ function getErrorSources(e: Error) {
  return [];
 }

-export function getOriginalRequestErrorMessages(error?: ExpressionRenderError | null): string[] {
-  const errorMessages = [];
+export function getOriginalRequestErrorMessages(
+  error: ExpressionRenderError | null,
+  docLinks: CoreStart['docLinks']
+): RemovableUserMessage[] {
+  const errorMessages: Array<string | { short: string; long: React.ReactNode }> = [];
  if (error && 'original' in error && error.original) {
    if (isEsAggError(error.original)) {
      if (isNetworkError(error.original)) {
@ -130,6 +144,34 @@ export function getOriginalRequestErrorMessages(error?: ExpressionRenderError |
              },
            })
          );
+        } else if (isTSDBError(rootError)) {
+          const [fieldName, _type, _isCounter, opUsed] = rootError.reason.match(/\[(\w)*\]/g)!;
+          const shortMessage = i18n.translate(
+            'xpack.lens.editorFrame.expressionTSDBDetailedMessage',
+            {
+              defaultMessage:
+                'The field {field} of Time series type [counter] has been used with the unsupported operation {op}.',
+              values: {
+                field: fieldName,
+                op: opUsed,
+              },
+            }
+          );
+          const message = (
+            <>
+              <p className="eui-textBreakWord">{shortMessage}</p>
+              <EuiLink href={docLinks.links.fleet.datastreamsTSDSMetrics} external target="_blank">
+                {i18n.translate('xpack.lens.editorFrame.expressionTSDBCounterInfo', {
+                  defaultMessage:
+                    'See more about Time series field types and [counter] supported aggregations',
+                })}
+              </EuiLink>
+            </>
+          );
+          errorMessages.push({
+            short: shortMessage,
+            long: message,
+          });
        } else {
          errorMessages.push(
            i18n.translate('xpack.lens.editorFrame.expressionFailureMessage', {
@ -144,9 +186,16 @@ export function getOriginalRequestErrorMessages(error?: ExpressionRenderError |
      }
    }
  } else if (error?.message) {
-    errorMessages.push(error?.message);
+    errorMessages.push(error.message);
  }
-  return errorMessages;
+  return errorMessages.map((message) => ({
+    uniqueId: typeof message === 'string' ? message : message.short,
+    severity: 'error',
+    displayLocations: [{ id: 'visualizationOnEmbeddable' }],
+    longMessage: typeof message === 'string' ? '' : message.long,
+    shortMessage: typeof message === 'string' ? message : message.short,
+    fixableInEditor: false,
+  }));
 }

 // NOTE - if you are adding a new error message, add it as a UserMessage in get_application_error_messages
--- a/x-pack/plugins/lens/public/embeddable/embeddable.tsx
+++ b/x-pack/plugins/lens/public/embeddable/embeddable.tsx
@ -964,6 +964,7 @@ export class Embeddable
                this.logError('runtime');
              }}
              noPadding={this.visDisplayOptions.noPadding}
+              docLinks={this.deps.coreStart.docLinks}
            />
          </KibanaThemeProvider>
          <MessagesBadge
--- a/x-pack/plugins/lens/public/embeddable/expression_wrapper.tsx
+++ b/x-pack/plugins/lens/public/embeddable/expression_wrapper.tsx
@ -12,7 +12,7 @@ import {
  ReactExpressionRendererProps,
  ReactExpressionRendererType,
 } from '@kbn/expressions-plugin/public';
-import type { KibanaExecutionContext } from '@kbn/core/public';
+import type { CoreStart, KibanaExecutionContext } from '@kbn/core/public';
 import { ExecutionContextSearch } from '@kbn/data-plugin/public';
 import { DefaultInspectorAdapters, RenderMode } from '@kbn/expressions-plugin/common';
 import classNames from 'classnames';
@ -46,6 +46,7 @@ export interface ExpressionWrapperProps {
  executionContext?: KibanaExecutionContext;
  lensInspector: LensInspector;
  noPadding?: boolean;
+  docLinks: CoreStart['docLinks'];
 }

 export function ExpressionWrapper({
@ -71,6 +72,7 @@ export function ExpressionWrapper({
  executionContext,
  lensInspector,
  noPadding,
+  docLinks,
 }: ExpressionWrapperProps) {
  if (!expression) return null;
  return (
@ -93,18 +95,9 @@ export function ExpressionWrapper({
          syncCursor={syncCursor}
          executionContext={executionContext}
          renderError={(errorMessage, error) => {
-            const messages = getOriginalRequestErrorMessages(error);
-            addUserMessages(
-              messages.map((message) => ({
-                uniqueId: message,
-                severity: 'error',
-                displayLocations: [{ id: 'visualizationOnEmbeddable' }],
-                longMessage: message,
-                shortMessage: message,
-                fixableInEditor: false,
-              }))
-            );
-            onRuntimeError(messages[0] ?? errorMessage);
+            const messages = getOriginalRequestErrorMessages(error || null, docLinks);
+            addUserMessages(messages);
+            onRuntimeError(messages[0].shortMessage ?? (errorMessage || ''));

            return <></>; // the embeddable will take care of displaying the messages
          }}