index_not_found_exception for .workflows_execitions is expected error (elastic#241938)

closes: elastic/security-team#14562

Skip index_not_found_exception error in get executions methods, because
it's expected (index is not created until first execution), so no need
to flood logs and raise errors for user

Author: VladimirFilonov

src/platform/plugins/shared/workflows_management/server/workflows_management/lib/search_workflow_executions.test.ts

@@ -0,0 +1,119 @@
+/*
+ * 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", the "GNU Affero General Public License v3.0 only", 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", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { errors } from '@elastic/elasticsearch';
+import type { ElasticsearchClient } from '@kbn/core/server';
+import { loggerMock } from '@kbn/logging-mocks';
+import { searchWorkflowExecutions } from './search_workflow_executions';
+
+describe('searchWorkflowExecutions', () => {
+  let mockEsClient: jest.Mocked<ElasticsearchClient>;
+  let mockLogger: ReturnType<typeof loggerMock.create>;
+
+  beforeEach(() => {
+    mockEsClient = {
+      search: jest.fn(),
+    } as any;
+
+    mockLogger = loggerMock.create();
+    mockLogger.info = jest.fn();
+    mockLogger.error = jest.fn();
+  });
+
+  describe('error handling', () => {
+    it('should not log error when index_not_found_exception occurs (expected behavior)', async () => {
+      mockLogger.error.mockClear();
+      const indexNotFoundError = new errors.ResponseError({
+        statusCode: 404,
+        body: {
+          error: {
+            type: 'index_not_found_exception',
+            reason: 'no such index [.workflows-executions]',
+          },
+        },
+        headers: {},
+        meta: {} as any,
+        warnings: [],
+      });
+
+      mockEsClient.search.mockRejectedValue(indexNotFoundError);
+
+      const result = await searchWorkflowExecutions({
+        esClient: mockEsClient,
+        logger: mockLogger,
+        workflowExecutionIndex: '.workflows-executions',
+        query: { term: { workflowId: 'workflow-1' } },
+        page: 1,
+        perPage: 20,
+      });
+
+      expect(result).toEqual({
+        results: [],
+        _pagination: {
+          limit: 20,
+          page: 1,
+          total: 0,
+        },
+      });
+
+      expect(mockLogger.error).not.toHaveBeenCalled();
+    });
+
+    it('should log error and throw when non-index_not_found_exception errors occur', async () => {
+      mockLogger.error.mockClear();
+      const otherError = new errors.ResponseError({
+        statusCode: 500,
+        body: {
+          error: {
+            type: 'internal_server_error',
+            reason: 'Internal server error',
+          },
+        },
+        headers: {},
+        meta: {} as any,
+        warnings: [],
+      });
+
+      mockEsClient.search.mockRejectedValue(otherError);
+
+      await expect(
+        searchWorkflowExecutions({
+          esClient: mockEsClient,
+          logger: mockLogger,
+          workflowExecutionIndex: '.workflows-executions',
+          query: { term: { workflowId: 'workflow-1' } },
+        })
+      ).rejects.toThrow(otherError);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to search workflow executions')
+      );
+    });
+
+    it('should log error and throw for non-ResponseError exceptions', async () => {
+      mockLogger.error.mockClear();
+      const genericError = new Error('Network error');
+
+      mockEsClient.search.mockRejectedValue(genericError);
+
+      await expect(
+        searchWorkflowExecutions({
+          esClient: mockEsClient,
+          logger: mockLogger,
+          workflowExecutionIndex: '.workflows-executions',
+          query: { term: { workflowId: 'workflow-1' } },
+        })
+      ).rejects.toThrow('Network error');
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to search workflow executions')
+      );
+    });
+  });
+});

src/platform/plugins/shared/workflows_management/server/workflows_management/lib/search_workflow_executions.ts

@@ -15,6 +15,7 @@ import type {
   Sort,
 } from '@elastic/elasticsearch/lib/api/types';
 import type { ElasticsearchClient, Logger } from '@kbn/core/server';
+import { isResponseError } from '@kbn/es-errors';
 import type { EsWorkflowExecution, WorkflowExecutionListDto } from '@kbn/workflows';
 
 interface SearchWorkflowExecutionsParams {
@@ -53,6 +54,18 @@ export const searchWorkflowExecutions = async ({
 
     return transformToWorkflowExecutionListModel(response, page, perPage);
   } catch (error) {
+    // Index not found is expected when no workflows have been executed yet
+    if (isResponseError(error) && error.body?.error?.type === 'index_not_found_exception') {
+      return {
+        results: [],
+        _pagination: {
+          limit: perPage,
+          page,
+          total: 0,
+        },
+      };
+    }
+
     logger.error(`Failed to search workflow executions: ${error}`);
     throw error;
   }

src/platform/plugins/shared/workflows_management/server/workflows_management/workflows_management_service.test.ts

@@ -618,6 +618,72 @@ describe('WorkflowsService', () => {
         );
       });
 
+      it('should not log error when index_not_found_exception occurs (expected behavior)', async () => {
+        mockLogger.error.mockClear();
+        const mockSearchResponse = {
+          hits: {
+            hits: [mockWorkflowDocument],
+            total: { value: 1 },
+          },
+        };
+
+        const indexNotFoundError = new errors.ResponseError({
+          statusCode: 404,
+          body: {
+            error: {
+              type: 'index_not_found_exception',
+              reason: 'no such index [.workflows-executions]',
+            },
+          },
+          headers: {},
+          meta: {} as any,
+          warnings: [],
+        });
+
+        mockEsClient.search
+          .mockResolvedValueOnce(mockSearchResponse as any)
+          .mockRejectedValueOnce(indexNotFoundError);
+
+        const result = await service.getWorkflows({ limit: 10, page: 1 }, 'default');
+
+        expect(result.results[0].history).toEqual([]);
+        expect(mockLogger.error).not.toHaveBeenCalled();
+      });
+
+      it('should log error when non-index_not_found_exception errors occur', async () => {
+        mockLogger.error.mockClear();
+        const mockSearchResponse = {
+          hits: {
+            hits: [mockWorkflowDocument],
+            total: { value: 1 },
+          },
+        };
+
+        const otherError = new errors.ResponseError({
+          statusCode: 500,
+          body: {
+            error: {
+              type: 'internal_server_error',
+              reason: 'Internal server error',
+            },
+          },
+          headers: {},
+          meta: {} as any,
+          warnings: [],
+        });
+
+        mockEsClient.search
+          .mockResolvedValueOnce(mockSearchResponse as any)
+          .mockRejectedValueOnce(otherError);
+
+        const result = await service.getWorkflows({ limit: 10, page: 1 }, 'default');
+
+        expect(result.results[0].history).toEqual([]);
+        expect(mockLogger.error).toHaveBeenCalledWith(
+          expect.stringContaining('Failed to fetch recent executions for workflows')
+        );
+      });
+
       it('should not fetch execution history for empty workflow list', async () => {
         const mockSearchResponse = {
           hits: {

src/platform/plugins/shared/workflows_management/server/workflows_management/workflows_management_service.ts

@@ -23,6 +23,7 @@ import type {
   Logger,
   SecurityServiceStart,
 } from '@kbn/core/server';
+import { isResponseError } from '@kbn/es-errors';
 import type { PublicMethodsOf } from '@kbn/utility-types';
 import type {
   ConnectorTypeInfo,
@@ -1006,7 +1007,10 @@ export class WorkflowsService {
 
       return result;
     } catch (error) {
-      this.logger.error(`Failed to fetch recent executions for workflows: ${error}`);
+      // Index not found is expected when no workflows have been executed yet
+      if (!isResponseError(error) || error.body?.error?.type !== 'index_not_found_exception') {
+        this.logger.error(`Failed to fetch recent executions for workflows: ${error}`);
+      }
       return {};
     }
   }

src/platform/plugins/shared/workflows_management/tsconfig.json

@@ -64,6 +64,7 @@
     "@kbn/core-http-router-server-mocks",
     "@kbn/react-query",
     "@kbn/core-http-server",
+    "@kbn/es-errors",
     "@kbn/core-http-server-mocks"
   ],
   "exclude": ["target/**/*"]