Merge pull request #4169 from RedisInsight/be/feature/RI-6215-investigate-sso-errors

RI-6215 added logging to cloud module

Author: vlad-dargel

redisinsight/api/src/common/utils/errors.util.ts

@@ -1,9 +1,14 @@
 import { HttpException, InternalServerErrorException } from '@nestjs/common';
+import { AxiosError } from 'axios';
 
-export const wrapHttpError = (error: Error, message?: string) => {
+export const wrapHttpError = (error: Error | AxiosError, message?: string) => {
   if (error instanceof HttpException) {
     return error;
   }
 
-  return new InternalServerErrorException(error.message || message);
+  const { response } = error as any;
+  const errorMessage = error.message || message || response?.data?.message;
+  const descriptionOrOptions = response?.data?.description || response?.data?.options;
+
+  return new InternalServerErrorException(errorMessage, descriptionOrOptions);
 };

redisinsight/api/src/modules/ai/chat/exceptions/conv-ai.error.handler.spec.ts

@@ -18,48 +18,50 @@ describe('wrapConvAiError', () => {
   it('Should return ConvAiBadRequestException of status code is 400', async () => {
     const error = wrapConvAiError(mockAiChatBadRequestError);
     expect(error).toBeInstanceOf(ConvAiBadRequestException);
-    expect(error).toEqual(new ConvAiBadRequestException());
+    expect(error).toEqual(new ConvAiBadRequestException(mockAiChatBadRequestError.message));
   });
   it('Should return ConvAiUnauthorizedException of status code is 401', async () => {
     const error = wrapConvAiError(mockAiChatUnauthorizedError);
     expect(error).toBeInstanceOf(ConvAiUnauthorizedException);
-    expect(error).toEqual(new ConvAiUnauthorizedException());
+    expect(error).toEqual(new ConvAiUnauthorizedException(mockAiChatUnauthorizedError.message));
   });
   it('Should return ConvAiForbiddenException of status code is 403', async () => {
     const error = wrapConvAiError(mockAiChatAccessDeniedError);
     expect(error).toBeInstanceOf(ConvAiForbiddenException);
-    expect(error).toEqual(new ConvAiForbiddenException());
+    expect(error).toEqual(new ConvAiForbiddenException(mockAiChatAccessDeniedError.message));
   });
   it('Should return ConvAiNotFoundException of status code is 404', async () => {
     const error = wrapConvAiError(mockAiChatNotFoundError);
     expect(error).toBeInstanceOf(ConvAiNotFoundException);
-    expect(error).toEqual(new ConvAiNotFoundException());
+    expect(error).toEqual(new ConvAiNotFoundException(mockAiChatNotFoundError.message));
   });
   it('Should return ConvAiInternalServerErrorException of status code is 500', async () => {
     const error = wrapConvAiError(mockAiChatInternalServerError);
     expect(error).toBeInstanceOf(ConvAiInternalServerErrorException);
-    expect(error).toEqual(new ConvAiInternalServerErrorException());
+    expect(error).toEqual(new ConvAiInternalServerErrorException(mockAiChatInternalServerError.message));
   });
   it('Should return ConvAiInternalServerErrorException by default', async () => {
+    const errorMessage = 'Unreachable error';
     const mockAxiosError = {
       response: {
         status: 503,
         data: {
-          message: 'Unreachable error',
+          message: errorMessage,
         },
       },
     } as AxiosError;
 
     const error = wrapConvAiError(mockAxiosError);
     expect(error).toBeInstanceOf(ConvAiInternalServerErrorException);
-    expect(error).toEqual(new ConvAiInternalServerErrorException());
+    expect(error).toEqual(new ConvAiInternalServerErrorException(errorMessage));
   });
   it('Should return ConvAiInternalServerErrorException if no response field', async () => {
-    const mockAxiosError = new Error('some other error') as AxiosError;
+    const errorMessage = 'some other error';
+    const mockAxiosError = new Error(errorMessage) as AxiosError;
 
     const error = wrapConvAiError(mockAxiosError);
     expect(error).toBeInstanceOf(ConvAiInternalServerErrorException);
-    expect(error).toEqual(new ConvAiInternalServerErrorException());
+    expect(error).toEqual(new ConvAiInternalServerErrorException(errorMessage));
   });
   it('Should return HttpException if passed children of it', async () => {
     const mockAxiosError = new BadRequestException() as unknown as AxiosError;

redisinsight/api/src/modules/ai/chat/exceptions/conv-ai.error.handler.ts

@@ -13,22 +13,28 @@ export const wrapConvAiError = (error: AxiosError, message?: string): HttpExcept
   }
 
   const { response } = error;
+  let errorMessage = message || error?.message;
+
+  if (!errorMessage) {
+    const data = response?.data as any;
+    errorMessage = data?.message;
+  }
 
   if (response) {
     const errorOptions = { cause: new Error(response?.data as string) };
     switch (response?.status) {
       case 401:
-        return new ConvAiUnauthorizedException(message, errorOptions);
+        return new ConvAiUnauthorizedException(errorMessage, errorOptions);
       case 403:
-        return new ConvAiForbiddenException(message, errorOptions);
+        return new ConvAiForbiddenException(errorMessage, errorOptions);
       case 400:
-        return new ConvAiBadRequestException(message, errorOptions);
+        return new ConvAiBadRequestException(errorMessage, errorOptions);
       case 404:
-        return new ConvAiNotFoundException(message, errorOptions);
+        return new ConvAiNotFoundException(errorMessage, errorOptions);
       default:
-        return new ConvAiInternalServerErrorException(message, errorOptions);
+        return new ConvAiInternalServerErrorException(errorMessage, errorOptions);
     }
   }
 
-  return new ConvAiInternalServerErrorException(message);
+  return new ConvAiInternalServerErrorException(errorMessage);
 };

redisinsight/api/src/modules/cloud/auth/cloud-auth.service.ts

@@ -156,6 +156,9 @@ export class CloudAuthService {
    */
   private async getAuthRequestInfo(query): Promise<CloudAuthRequestInfo> {
     if (!this.authRequests.has(query?.state)) {
+      this.logger.log(
+        `${query?.state ? 'Auth Request matching query state not found' : 'Query state field is empty'}`,
+      );
       throw new CloudOauthUnknownAuthorizationRequestException();
     }
 
@@ -175,12 +178,17 @@ export class CloudAuthService {
    */
   private async callback(query): Promise<Function | void> {
     if (!this.authRequests.has(query?.state)) {
+      this.logger.log(
+        `${query?.state ? 'Auth Request matching query state not found' : 'Query state field is empty'}`,
+      );
       throw new CloudOauthUnknownAuthorizationRequestException();
     }
 
     const authRequest = this.authRequests.get(query.state);
 
     if (query?.error) {
+      this.logger.error(`Query has error field: query.error: ${query.error},
+        query.error_description: ${query.error_description}`);
       throw CloudAuthService.getAuthorizationServerRedirectError(query, authRequest);
     }
 
@@ -228,6 +236,7 @@ export class CloudAuthService {
    * @param from
    */
   async handleCallback(query, from = CloudSsoFeatureStrategy.DeepLink): Promise<CloudAuthResponse> {
+    this.logger.log(`Handling a callback with a query having ${Object.keys(query || {}).toString()} keys`);
     let result: CloudAuthResponse = {
       status: CloudAuthStatus.Succeed,
       message: 'Successfully authenticated',
@@ -240,7 +249,7 @@ export class CloudAuthService {
       callback = await this.callback(query);
       this.analytics.sendCloudSignInSucceeded(from, reqInfo?.action);
     } catch (e) {
-      this.logger.error(`Error on ${from} cloud oauth callback`, e);
+      this.logger.error(`Error on ${from} cloud oauth callback: ${e.message}`, e);
 
       this.analytics.sendCloudSignInFailed(e, from, reqInfo?.action);
 
@@ -251,6 +260,9 @@ export class CloudAuthService {
     }
 
     try {
+      if (!callback) {
+        this.logger.log('Callback is undefined');
+      }
       callback?.(result)?.catch((e: Error) => this.logger.error('Async callback failed', e));
     } catch (e) {
       this.logger.error('Callback failed', e);
@@ -278,7 +290,8 @@ export class CloudAuthService {
         apiSessionId: null,
       });
     } catch (e) {
-      throw new CloudApiUnauthorizedException();
+      this.logger.error('Unable to renew tokens', e);
+      throw new CloudApiUnauthorizedException(e.message);
     }
   }
 

redisinsight/api/src/modules/cloud/autodiscovery/cloud-autodiscovery.service.ts

@@ -47,6 +47,7 @@ export class CloudAutodiscoveryService {
     try {
       return await this.cloudUserCapiService.getCurrentAccount(authDto);
     } catch (e) {
+      this.logger.error('Error when getting current user account', e);
       throw wrapHttpError(e);
     }
   }
@@ -67,6 +68,7 @@ export class CloudAutodiscoveryService {
       this.analytics.sendGetRECloudSubsSucceedEvent(subscriptions, type, authType);
       return subscriptions;
     } catch (e) {
+      this.logger.error('Failed get redis cloud subscriptions', e);
       this.analytics.sendGetRECloudSubsFailedEvent(e, type, authType);
       throw wrapHttpError(e);
     }
@@ -117,6 +119,7 @@ export class CloudAutodiscoveryService {
       this.analytics.sendGetRECloudDbsSucceedEvent(result, authType);
       return result;
     } catch (e) {
+      this.logger.error('Error when discovering cloud databases from subscription(s)', e);
       this.analytics.sendGetRECloudDbsFailedEvent(e, authType);
 
       throw wrapHttpError(e);
@@ -181,6 +184,7 @@ export class CloudAutodiscoveryService {
               databaseDetails: database,
             };
           } catch (error) {
+            this.logger.error('Adding cloud database failed with an error', error);
             return {
               ...dto,
               status: ActionStatus.Fail,

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.service.ts

@@ -47,6 +47,7 @@ export class CloudCapiKeyService {
       let currentAccount = CloudUserApiService.getCurrentAccount(user);
 
       if (!currentAccount) {
+        this.logger.error('Cannot get current account');
         throw new CloudApiBadRequestException('No active account');
       }
 
@@ -87,13 +88,15 @@ export class CloudCapiKeyService {
 
           this.analytics.sendCloudAccountKeyGenerated();
         } catch (e) {
+          this.logger.error('Failed to create new capi key', e);
           this.analytics.sendCloudAccountKeyGenerationFailed(e);
           throw e;
         }
       }
 
       // Throw an error. User action required in this case
       if (capiKey.valid === false) {
+        this.logger.error('Capi key is not valid');
         return Promise.reject(new CloudCapiKeyUnauthorizedException(
           undefined,
           { resourceId: capiKey.id },
@@ -114,6 +117,7 @@ export class CloudCapiKeyService {
 
           this.analytics.sendCloudAccountSecretGenerated();
         } catch (e) {
+          this.logger.error('Failed create capi secret');
           this.analytics.sendCloudAccountSecretGenerationFailed(e);
           throw e;
         }

redisinsight/api/src/modules/cloud/common/exceptions/cloud-api.error.handler.ts

@@ -15,21 +15,27 @@ export const wrapCloudApiError = (error: AxiosError, message?: string): HttpExce
 
   const { response } = error;
 
+  let errorMessage = message || error.message;
+  if (!errorMessage) {
+    const data = response?.data as any;
+    errorMessage = data?.message;
+  }
+
   if (response) {
     const errorOptions = { cause: new Error(response?.data as string) };
     switch (response?.status) {
       case 401:
-        return new CloudApiUnauthorizedException(message, errorOptions);
+        return new CloudApiUnauthorizedException(errorMessage, errorOptions);
       case 403:
-        return new CloudApiForbiddenException(message, errorOptions);
+        return new CloudApiForbiddenException(errorMessage, errorOptions);
       case 400:
-        return new CloudApiBadRequestException(message, errorOptions);
+        return new CloudApiBadRequestException(errorMessage, errorOptions);
       case 404:
-        return new CloudApiNotFoundException(message, errorOptions);
+        return new CloudApiNotFoundException(errorMessage, errorOptions);
       default:
-        return new CloudApiInternalServerErrorException(message, errorOptions);
+        return new CloudApiInternalServerErrorException(errorMessage, errorOptions);
     }
   }
 
-  return new CloudApiInternalServerErrorException(message);
+  return new CloudApiInternalServerErrorException(errorMessage);
 };

redisinsight/api/src/modules/cloud/common/exceptions/cloud-capi.error.handler.ts

@@ -9,7 +9,10 @@ export const wrapCloudCapiError = (error: AxiosError, message?: string): HttpExc
   }
 
   if (error.response?.status === 401) {
-    return new CloudCapiUnauthorizedException(message, { cause: new Error(error.response?.data as string) });
+    return new CloudCapiUnauthorizedException(
+      message || error.message,
+      { cause: new Error(error.response?.data as string) },
+    );
   }
 
   return wrapCloudApiError(error, message);

redisinsight/api/src/modules/cloud/subscription/cloud-subscription.api.service.ts

@@ -69,6 +69,7 @@ export class CloudSubscriptionApiService {
           details: find(regions, { regionId: plan.regionId }),
         }));
       } catch (e) {
+        this.logger.error('Error getting subscription plans', e);
         throw wrapHttpError(await this.cloudCapiKeyService.handleCapiKeyUnauthorizedError(e, sessionMetadata));
       }
     });
@@ -89,6 +90,7 @@ export class CloudSubscriptionApiService {
 
       return parseCloudSubscriptionsCloudRegionsApiResponse(regions);
     } catch (error) {
+      this.logger.error('Error getting cloud regions', error);
       throw wrapHttpError(error);
     }
   }

redisinsight/api/src/modules/cloud/subscription/cloud-subscription.capi.service.ts

@@ -68,6 +68,7 @@ export class CloudSubscriptionCapiService {
 
       return parseCloudSubscriptionsCapiResponse(subscriptions, type);
     } catch (error) {
+      this.logger.error(`Error getting ${type} subscriptions`, error);
       throw wrapHttpError(error);
     }
   }
@@ -91,6 +92,7 @@ export class CloudSubscriptionCapiService {
 
       return parseCloudSubscriptionCapiResponse(subscription, type);
     } catch (error) {
+      this.logger.error(`Error getting ${type} subscription`, error);
       throw wrapHttpError(error);
     }
   }
@@ -112,6 +114,7 @@ export class CloudSubscriptionCapiService {
 
       return parseCloudSubscriptionsPlansCapiResponse(plans, type);
     } catch (error) {
+      this.logger.error('Error getting subscriptions plans', error);
       throw wrapHttpError(error);
     }
   }
@@ -137,6 +140,7 @@ export class CloudSubscriptionCapiService {
 
       return parseCloudTaskCapiResponse(task);
     } catch (error) {
+      this.logger.error('Error when creating free subscription task', error);
       throw wrapHttpError(error);
     }
   }