Let addLastRunError to report user errors

x-pack/plugins/alerting/server/lib/last_run_status.test.ts

@@ -39,7 +39,7 @@ const getRuleResultService = ({
   const ruleResultService = new RuleResultService();
   const { addLastRunError, addLastRunWarning, setLastRunOutcomeMessage } =
     ruleResultService.getLastRunSetters();
-  errors.forEach((error) => addLastRunError(error));
+  errors.forEach((error) => addLastRunError(error.message));
   warnings.forEach((warning) => addLastRunWarning(warning));
   setLastRunOutcomeMessage(outcomeMessage);
   return ruleResultService;
@@ -250,7 +250,7 @@ describe('lastRunFromState', () => {
         metrics: getMetrics({ hasReachedAlertLimit: true }),
       },
       getRuleResultService({
-        errors: ['MOCK_ERROR'],
+        errors: [{ message: 'MOCK_ERROR', userError: false }],
         outcomeMessage: 'Rule execution reported an error',
       })
     );

x-pack/plugins/alerting/server/lib/rule_execution_status.ts

@@ -76,7 +76,7 @@ export function executionStatusFromState({
     // These errors are reported by ruleResultService.addLastRunError, therefore they are landed in successful execution map
     error = {
       reason: RuleExecutionStatusErrorReasons.Unknown,
-      message: errorsFromLastRun.join(','),
+      message: errorsFromLastRun.map((lastRunError) => lastRunError.message).join(','),
     };
   }
 

x-pack/plugins/alerting/server/monitoring/rule_result_service.test.ts

@@ -31,7 +31,16 @@ describe('RuleResultService', () => {
 
   test('should return errors array with added error', () => {
     lastRunSetters.addLastRunError('First error');
-    expect(ruleResultService.getLastRunErrors()).toEqual(['First error']);
+    expect(ruleResultService.getLastRunErrors()).toEqual([
+      { message: 'First error', userError: false },
+    ]);
+  });
+
+  test('should return errors array with added user error', () => {
+    lastRunSetters.addLastRunError('First error', true);
+    expect(ruleResultService.getLastRunErrors()).toEqual([
+      { message: 'First error', userError: true },
+    ]);
   });
 
   test('should return warnings array with added warning', () => {
@@ -49,7 +58,12 @@ describe('RuleResultService', () => {
     lastRunSetters.addLastRunWarning('warning');
     lastRunSetters.setLastRunOutcomeMessage('outcome message');
     const expectedLastRun: RuleResultServiceResults = {
-      errors: ['error'],
+      errors: [
+        {
+          message: 'error',
+          userError: false,
+        },
+      ],
       warnings: ['warning'],
       outcomeMessage: 'outcome message',
     };
@@ -63,7 +77,16 @@ describe('RuleResultService', () => {
     lastRunSetters.setLastRunOutcomeMessage('second outcome message');
     lastRunSetters.setLastRunOutcomeMessage('last outcome message');
     const expectedLastRun = {
-      errors: ['first error', 'second error'],
+      errors: [
+        {
+          message: 'first error',
+          userError: false,
+        },
+        {
+          message: 'second error',
+          userError: false,
+        },
+      ],
       warnings: [],
       outcomeMessage: 'last outcome message',
     };

x-pack/plugins/alerting/server/monitoring/rule_result_service.ts

@@ -8,17 +8,22 @@
 import { PublicLastRunSetters } from '../types';
 
 export interface RuleResultServiceResults {
-  errors: string[];
+  errors: LastRunError[];
   warnings: string[];
   outcomeMessage: string;
 }
 
+interface LastRunError {
+  message: string;
+  userError?: boolean;
+}
+
 export class RuleResultService {
-  private errors: string[] = [];
+  private errors: LastRunError[] = [];
   private warnings: string[] = [];
   private outcomeMessage: string = '';
 
-  public getLastRunErrors(): string[] {
+  public getLastRunErrors(): LastRunError[] {
     return this.errors;
   }
 
@@ -46,8 +51,8 @@ export class RuleResultService {
     };
   }
 
-  private addLastRunError(error: string) {
-    this.errors.push(error);
+  private addLastRunError(message: string, userError: boolean = false) {
+    this.errors.push({ message, userError });
   }
 
   private addLastRunWarning(warning: string) {

x-pack/plugins/alerting/server/task_runner/task_runner.test.ts

@@ -3311,7 +3311,10 @@ describe('Task Runner', () => {
     });
 
     ruleResultService.getLastRunResults.mockImplementation(() => ({
-      errors: ['an error occurred'],
+      errors: [
+        { message: 'an error occurred', userError: false },
+        { message: 'second error occurred', userError: true },
+      ],
       warnings: [],
       outcomeMessage: '',
     }));
@@ -3325,13 +3328,38 @@ describe('Task Runner', () => {
     testAlertingEventLogCalls({
       status: 'error',
       softErrorFromLastRun: true,
-      errorMessage: 'an error occurred',
+      errorMessage: 'an error occurred,second error occurred',
       errorReason: 'unknown',
     });
 
     expect(getErrorSource(runnerResult.taskRunError as Error)).toBe(TaskErrorSource.FRAMEWORK);
   });
 
+  test('returns user error if all the errors are user error', async () => {
+    rulesClient.getAlertFromRaw.mockReturnValue(mockedRuleTypeSavedObject as Rule);
+    encryptedSavedObjectsClient.getDecryptedAsInternalUser.mockResolvedValue(mockedRawRuleSO);
+
+    const taskRunner = new TaskRunner({
+      ruleType,
+      taskInstance: mockedTaskInstance,
+      context: taskRunnerFactoryInitializerParams,
+      inMemoryMetrics,
+    });
+
+    ruleResultService.getLastRunResults.mockImplementation(() => ({
+      errors: [
+        { message: 'an error occurred', userError: true },
+        { message: 'second error occurred', userError: true },
+      ],
+      warnings: [],
+      outcomeMessage: '',
+    }));
+
+    const runnerResult = await taskRunner.run();
+
+    expect(getErrorSource(runnerResult.taskRunError as Error)).toBe(TaskErrorSource.USER);
+  });
+
   function testAlertingEventLogCalls({
     ruleContext = alertingEventLoggerInitializer,
     activeAlerts = 0,

x-pack/plugins/alerting/server/task_runner/task_runner.ts

@@ -715,10 +715,11 @@ export class TaskRunner<
 
       const { errors: errorsFromLastRun } = this.ruleResult.getLastRunResults();
       if (errorsFromLastRun.length > 0) {
+        const isUserError = !errorsFromLastRun.some((lastRunError) => !lastRunError.userError);
         return {
           taskRunError: createTaskRunError(
             new Error(errorsFromLastRun.join(',')),
-            TaskErrorSource.FRAMEWORK
+            isUserError ? TaskErrorSource.USER : TaskErrorSource.FRAMEWORK
           ),
         };
       }

x-pack/plugins/alerting/server/types.ts

@@ -414,7 +414,7 @@ export interface PublicMetricsSetters {
 }
 
 export interface PublicLastRunSetters {
-  addLastRunError: (outcome: string) => void;
+  addLastRunError: (message: string, userError?: boolean) => void;
   addLastRunWarning: (outcomeMsg: string) => void;
   setLastRunOutcomeMessage: (warning: string) => void;
 }