[Job Launcher] Remove unnecessary data from logs (#3682)

Author: flopez7

packages/apps/dashboard/server/src/modules/stats/stats.service.ts

@@ -392,47 +392,66 @@ export class StatsService implements OnModuleInit {
       return cachedHmtPrice;
     }
 
-    const headers = this.envConfigService.hmtPriceSourceApiKey
-      ? { 'x-cg-demo-api-key': this.envConfigService.hmtPriceSourceApiKey }
-      : {};
+    try {
+      const headers = this.envConfigService.hmtPriceSourceApiKey
+        ? { 'x-cg-demo-api-key': this.envConfigService.hmtPriceSourceApiKey }
+        : {};
 
-    const { data } = await lastValueFrom(
-      this.httpService.get(this.envConfigService.hmtPriceSource, { headers }),
-    );
+      const { data } = await lastValueFrom(
+        this.httpService.get(this.envConfigService.hmtPriceSource, { headers }),
+      );
 
-    let hmtPrice: number;
-
-    if (this.envConfigService.hmtPriceSource.includes('coingecko')) {
-      if (
-        !data ||
-        !data[this.envConfigService.hmtPriceFromKey] ||
-        !data[this.envConfigService.hmtPriceFromKey][
-          this.envConfigService.hmtPriceToKey
-        ]
-      ) {
-        throw new Error('Failed to fetch HMT price from CoinGecko API');
+      let hmtPrice: number;
+
+      if (this.envConfigService.hmtPriceSource.includes('coingecko')) {
+        if (
+          !data ||
+          !data[this.envConfigService.hmtPriceFromKey] ||
+          !data[this.envConfigService.hmtPriceFromKey][
+            this.envConfigService.hmtPriceToKey
+          ]
+        ) {
+          throw new Error('Failed to fetch HMT price from CoinGecko API');
+        }
+        hmtPrice = parseFloat(
+          data[this.envConfigService.hmtPriceFromKey][
+            this.envConfigService.hmtPriceToKey
+          ],
+        );
+      } else if (this.envConfigService.hmtPriceSource.includes('coinlore')) {
+        if (
+          !data ||
+          !data[0] ||
+          !data[0].price_usd ||
+          data[0].symbol !== 'HMT'
+        ) {
+          throw new Error('Failed to fetch HMT price from Coinlore API');
+        }
+        hmtPrice = parseFloat(data[0].price_usd);
+      } else {
+        throw new Error('Unsupported HMT price source');
       }
-      hmtPrice = parseFloat(
-        data[this.envConfigService.hmtPriceFromKey][
-          this.envConfigService.hmtPriceToKey
-        ],
+
+      await this.cacheManager.set(
+        this.redisConfigService.hmtPriceCacheKey,
+        hmtPrice,
+        this.redisConfigService.cacheHmtPriceTTL,
       );
-    } else if (this.envConfigService.hmtPriceSource.includes('coinlore')) {
-      if (!data || !data[0] || !data[0].price_usd || data[0].symbol !== 'HMT') {
-        throw new Error('Failed to fetch HMT price from Coinlore API');
+
+      return hmtPrice;
+    } catch (error) {
+      let formattedError = error;
+      if (error instanceof AxiosError) {
+        formattedError = httpUtils.formatAxiosError(error);
       }
-      hmtPrice = parseFloat(data[0].price_usd);
-    } else {
-      throw new Error('Unsupported HMT price source');
-    }
 
-    await this.cacheManager.set(
-      this.redisConfigService.hmtPriceCacheKey,
-      hmtPrice,
-      this.redisConfigService.cacheHmtPriceTTL,
-    );
+      this.logger.error('Failed to fetch HMT price', {
+        source: this.envConfigService.hmtPriceSource,
+        error: formattedError,
+      });
 
-    return hmtPrice;
+      throw error;
+    }
   }
 
   async hCaptchaStats(from: string, to: string): Promise<HcaptchaDailyStats[]> {

packages/apps/job-launcher/server/src/common/utils/hcaptcha.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import { formatAxiosError } from './http';
 
 export async function verifyToken(
   url: string,
@@ -17,11 +18,18 @@ export async function verifyToken(
     queryParams.remoteip = ip;
   }
 
-  const { data } = await axios.post(
-    `${url}/siteverify`,
-    {},
-    { params: queryParams },
-  );
+  try {
+    const { data } = await axios.post(
+      `${url}/siteverify`,
+      {},
+      { params: queryParams },
+    );
 
-  return data;
+    return data;
+  } catch (error) {
+    return {
+      success: false,
+      error: formatAxiosError(error),
+    };
+  }
 }

packages/apps/job-launcher/server/src/common/utils/slack.ts

@@ -1,6 +1,7 @@
 import axios from 'axios';
 
 import logger from '../../logger';
+import { formatAxiosError } from './http';
 
 const slackLogger = logger.child({ context: 'sendSlackNotification' });
 
@@ -21,7 +22,9 @@ export async function sendSlackNotification(
     slackLogger.debug('Slack notification sent', payload);
     return true;
   } catch (error) {
-    slackLogger.error('Error sending Slack notification', error);
+    slackLogger.error('Error sending Slack notification', {
+      error: formatAxiosError(error),
+    });
     return false;
   }
 }

packages/apps/job-launcher/server/src/common/utils/storage.ts

@@ -1,5 +1,5 @@
 import { HttpStatus } from '@nestjs/common';
-import axios from 'axios';
+import axios, { AxiosError } from 'axios';
 import { parseString } from 'xml2js';
 import { StorageDataDto } from '../../modules/job/job.dto';
 import { ErrorBucket } from '../constants/errors';
@@ -10,6 +10,7 @@ import {
   GCS_HTTP_REGEX_PATH_BASED,
   GCS_HTTP_REGEX_SUBDOMAIN,
 } from './gcstorage';
+import { formatAxiosError } from './http';
 
 export function generateBucketUrl(
   storageData: StorageDataDto,
@@ -140,7 +141,11 @@ export async function listObjectsInBucket(url: URL): Promise<string[]> {
       } while (nextContinuationToken);
       resolve(objects);
     } catch (err) {
-      reject(err);
+      let formatted = err;
+      if (err instanceof AxiosError) {
+        formatted = formatAxiosError(err);
+      }
+      reject(formatted);
     }
   });
 }

packages/apps/job-launcher/server/src/modules/auth/auth.service.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 
 import { ErrorAuth, ErrorUser } from '../../common/constants/errors';
@@ -39,6 +39,8 @@ import { ApiKeyRepository } from './apikey.repository';
 
 @Injectable()
 export class AuthService {
+  private readonly logger = new Logger(AuthService.name);
+
   constructor(
     private readonly jwtService: JwtService,
     private readonly userService: UserService,
@@ -80,19 +82,7 @@ export class AuthService {
   }
 
   public async signup(data: UserCreateDto, ip?: string): Promise<UserEntity> {
-    if (
-      !(
-        await verifyToken(
-          this.authConfigService.hcaptchaProtectionUrl,
-          this.authConfigService.hCaptchaSiteKey,
-          this.authConfigService.hCaptchaSecret,
-          data.hCaptchaToken,
-          ip,
-        )
-      ).success
-    ) {
-      throw new ForbiddenError(ErrorAuth.InvalidCaptchaToken);
-    }
+    await this.ensureCaptchaValid(data.hCaptchaToken, ip);
     const storedUser = await this.userRepository.findByEmail(data.email);
     if (storedUser) {
       throw new ConflictError(ErrorUser.DuplicatedEmail);
@@ -185,19 +175,7 @@ export class AuthService {
     data: ForgotPasswordDto,
     ip?: string,
   ): Promise<void> {
-    if (
-      !(
-        await verifyToken(
-          this.authConfigService.hcaptchaProtectionUrl,
-          this.authConfigService.hCaptchaSiteKey,
-          this.authConfigService.hCaptchaSecret,
-          data.hCaptchaToken,
-          ip,
-        )
-      ).success
-    ) {
-      throw new ForbiddenError(ErrorAuth.InvalidCaptchaToken);
-    }
+    await this.ensureCaptchaValid(data.hCaptchaToken, ip);
     const userEntity = await this.userRepository.findByEmail(data.email);
 
     if (!userEntity) {
@@ -245,19 +223,7 @@ export class AuthService {
     data: RestorePasswordDto,
     ip?: string,
   ): Promise<void> {
-    if (
-      !(
-        await verifyToken(
-          this.authConfigService.hcaptchaProtectionUrl,
-          this.authConfigService.hCaptchaSiteKey,
-          this.authConfigService.hCaptchaSecret,
-          data.hCaptchaToken,
-          ip,
-        )
-      ).success
-    ) {
-      throw new ForbiddenError(ErrorAuth.InvalidCaptchaToken);
-    }
+    await this.ensureCaptchaValid(data.hCaptchaToken, ip);
 
     const tokenEntity = await this.tokenRepository.findOneByUuidAndType(
       data.token,
@@ -426,4 +392,24 @@ export class AuthService {
 
     return null;
   }
+
+  private async ensureCaptchaValid(token: string, ip?: string): Promise<void> {
+    const verification = await verifyToken(
+      this.authConfigService.hcaptchaProtectionUrl,
+      this.authConfigService.hCaptchaSiteKey,
+      this.authConfigService.hCaptchaSecret,
+      token,
+      ip,
+    );
+
+    if (verification.success) {
+      return;
+    }
+
+    this.logger.error(ErrorAuth.InvalidCaptchaToken, {
+      error: verification.error,
+    });
+
+    throw new ForbiddenError(ErrorAuth.InvalidCaptchaToken);
+  }
 }

packages/apps/job-launcher/server/src/modules/qualification/qualification.service.ts

@@ -5,9 +5,10 @@ import { firstValueFrom } from 'rxjs';
 import { Web3ConfigService } from '../../common/config/web3-config.service';
 import { ErrorQualification, ErrorWeb3 } from '../../common/constants/errors';
 import { ServerError } from '../../common/errors';
+import { formatAxiosError } from '../../common/utils/http';
+import logger from '../../logger';
 import { Web3Service } from '../web3/web3.service';
 import { QualificationDto } from './qualification.dto';
-import logger from '../../logger';
 
 @Injectable()
 export class QualificationService {
@@ -48,9 +49,10 @@ export class QualificationService {
 
       return data;
     } catch (error) {
+      const formattedError = formatAxiosError(error);
       this.logger.error(
         'Error fetching qualifications from reputation oracle',
-        error,
+        { error: formattedError },
       );
       throw new ServerError(ErrorQualification.FailedToFetchQualifications);
     }

packages/apps/job-launcher/server/src/modules/rate/rate.service.ts

@@ -7,6 +7,7 @@ import { ErrorCurrency } from '../../common/constants/errors';
 import { CoingeckoTokenId } from '../../common/constants/payment';
 import { EscrowFundToken } from '../../common/enums/job';
 import { NotFoundError } from '../../common/errors';
+import { formatAxiosError } from '../../common/utils/http';
 import logger from '../../logger';
 
 @Injectable()
@@ -77,10 +78,11 @@ export class RateService {
 
       return finalRate;
     } catch (error) {
+      const formattedError = formatAxiosError(error);
       this.logger.error('Error while getting rate', {
         from,
         to,
-        error,
+        error: formattedError,
       });
       throw new NotFoundError(ErrorCurrency.PairNotFound);
     }

packages/apps/reputation-oracle/server/src/integrations/hcaptcha/hcaptcha.service.ts

@@ -1,10 +1,12 @@
 import { HttpService } from '@nestjs/axios';
 import { Injectable } from '@nestjs/common';
+import { AxiosError } from 'axios';
 import { ethers } from 'ethers';
 import { firstValueFrom } from 'rxjs';
 
 import { HCaptchaConfigService } from '@/config';
 import logger from '@/logger';
+import { formatAxiosError } from '@/utils/http';
 
 import {
   GetLabelerQueryParams,
@@ -59,7 +61,13 @@ export class HCaptchaService {
         });
       }
     } catch (error) {
-      this.logger.error('Error occurred during token verification', error);
+      let formattedError = error;
+      if (error instanceof AxiosError) {
+        formattedError = formatAxiosError(error);
+      }
+      this.logger.error('Error occurred during token verification', {
+        error: formattedError,
+      });
     }
 
     return false;
@@ -105,8 +113,12 @@ export class HCaptchaService {
         });
       }
     } catch (error) {
+      let formattedError = error;
+      if (error instanceof AxiosError) {
+        formattedError = formatAxiosError(error);
+      }
       this.logger.error('Error occurred during labeling registration', {
-        error,
+        error: formattedError,
         ...data,
       });
     }
@@ -134,8 +146,12 @@ export class HCaptchaService {
         return response.data;
       }
     } catch (error) {
+      let formattedError = error;
+      if (error instanceof AxiosError) {
+        formattedError = formatAxiosError(error);
+      }
       this.logger.error(`Error occurred while retrieving labeler data`, {
-        error,
+        error: formattedError,
         email,
       });
     }