@meltwater/conversations-api-services 1.0.19 → 1.0.21

package/dist/esm/data-access/http/ir.client.js

@@ -0,0 +1,234 @@
+import { v4 } from 'uuid';
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+import { metricN } from '../../lib/metrics.helper.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class IRClient {
+  RETRY_COUNT = 50;
+  constructor(context) {
+    const {
+      company,
+      user,
+      traceId,
+      metrics
+    } = context;
+    this.company = company;
+    this.user = user;
+    this.traceId = traceId;
+    this.metrics = metrics;
+  }
+  async init() {
+    let irApiKey = configuration.get('IR_API_KEY');
+    this.searchServicesUrl = configuration.get('SEARCH_SERVICE_URL');
+    this.searchServicesKey = irApiKey;
+    this.documentRevisionsServiceUrl = configuration.get('DOCUMENT_REVISIONS_SERVICE_URL');
+    this.documentServiceUrl = configuration.get('DOCUMENT_SERVICE_URL');
+    this.documentServiceKey = irApiKey;
+    this.exportApiUrl = configuration.get('EXPORT_API_URL');
+    this.exportApiKey = irApiKey;
+  }
+  async addRevisionsToDocuments(operations) {
+    await this.init();
+    const wait = 100;
+    const url = `${this.documentRevisionsServiceUrl}/${this.company._id}/`;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: this.company._id
+    });
+    let result;
+    try {
+      result = await superagent.patch(url).query({
+        wait,
+        apikey: this.documentServiceKey
+      }).set('x-client-name', 'engage-conversations').send(operations).then(result => result.body);
+    } catch (error) {
+      loggerChild.error(`Failed adding a revisions with operations`, error, {
+        url,
+        [MeltwaterAttributes.COMPANYID]: this.company._id,
+        operations: JSON.stringify(operations)
+      });
+      return;
+    }
+    loggerChild.info(`Finished adding revision operations`, {
+      operations: JSON.stringify(operations)
+    });
+    return result;
+  }
+  async modifyDocuments(operations) {
+    let retryAttempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    await this.init();
+    const wait = 100;
+    const url = `${this.documentServiceUrl}/`;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: this.company._id
+    });
+    let result;
+    try {
+      result = await superagent.patch(url).query({
+        wait,
+        apikey: this.documentServiceKey
+      }).set('x-client-name', 'engage-conversations').send(operations).then(result => result.body);
+    } catch (err) {
+      retryAttempt++;
+      if (retryAttempt > this.RETRY_COUNT) {
+        loggerChild.error(`Maximum Retrys hit for method modifyDocuments ${err.status} ${err.message}`, err, {
+          [MeltwaterAttributes.COMPANYID]: this.company._id
+        });
+      } else if (await this.retryBecauseRateLimiting(err, 'modifyDocuments')) {
+        return await this.modifyDocuments(operations, retryAttempt);
+      }
+    }
+    loggerChild.info(`Finished modifying documents operations`, {
+      operations: JSON.stringify(operations)
+    });
+    return result;
+  }
+  async getDocumentById(id) {
+    let retryAttempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    await this.init();
+    try {
+      const uri = `${this.documentServiceUrl}/${id}/revisions/${this.company._id}?apikey=${this.documentServiceKey}`;
+      const metric = this.metrics.count(metricNames.irGetByDocumentId);
+      const result = await superagent.get(uri);
+      this.metrics.finishOperation(metricNames.irGetByDocumentId, metric);
+      return result.body;
+    } catch (err) {
+      retryAttempt++;
+      if (retryAttempt > this.RETRY_COUNT) {
+        logger.error(`Maximum Retrys hit for method getDocumentById ${err.status} ${err.message}`, err, {
+          [MeltwaterAttributes.COMPANYID]: this.company._id
+        });
+      } else if (await this.retryBecauseRateLimiting(err, 'getDocumentById')) {
+        return await this.getDocumentById(id, retryAttempt);
+      }
+    }
+  }
+  async retryBecauseRateLimiting(err, name) {
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: this.company._id
+    });
+
+    // rate limit error
+    if (err.status === 429) {
+      this.metrics.count(metricNames.irRatelimited);
+      loggerChild.error(`Error Accessing ir.client method because rate limit: trying again ${name}`, err);
+      // should not be hitting rate limit in production
+      // this is a patch for staging testing
+      await new Promise(resolve => setTimeout(resolve, 100));
+      return true;
+    }
+    if (err.status == 404) {
+      loggerChild.info(`Document Not Found ir.client method ${name} ${err.status} ${err.message}`, err);
+    } else {
+      loggerChild.info(`Could not access ir.client method ${name} ${err.status} ${err.message}`, err);
+    }
+    return false;
+  }
+  async export(rune) {
+    await this.init();
+    const traceId = this.generateTraceId();
+    try {
+      let uri = `${this.exportApiUrl}?apikey=${this.exportApiKey}`;
+      logger.info(`Starting call to : ${this.exportApiUrl}`, {
+        rune
+      });
+      this.addCompanyToRuneForHorace(rune);
+      let result = await superagent.post(uri).query({
+        traceId
+      }).send(rune);
+      logger.info(`Finished calling Export API: ${result.body.exportKey}`, {
+        irTraceId: traceId
+      });
+      return result.body.exportKey;
+    } catch (err) {
+      logger.error('Error executing search against Export API', err);
+    }
+  }
+  async search(rune) {
+    await this.init();
+    const traceId = this.generateTraceId();
+    try {
+      let uri = `${this.searchServicesUrl}?apikey=${this.searchServicesKey}`;
+
+      // todo: remove changing rune searchResults size
+      // todo: remove reduce ( dedupes and trims to original rune limit )
+      // rune limit is a bandaid, hopefully better solution can be worked out with Horace
+      let limitActual = rune.viewRequests.searchResults.size;
+      rune.viewRequests.searchResults.size = limitActual * 2;
+      this.addCompanyToRuneForHorace(rune);
+      const metric = this.metrics.count(metricNames.irSearch);
+      let result = await superagent.post(uri).query({
+        traceId
+      }).send(rune);
+      this.metrics.finishOperation(metricNames.irSearch, metric);
+      rune.viewRequests.searchResults.size = limitActual;
+      const finalResults = result.body.views.searchResults.results.reduce((acc, document, index) => {
+        if (!index || acc.length <= limitActual && acc[acc.length - 1].documentId !== document.quiddity.id) {
+          acc.push(document.quiddity);
+        } else if (index && acc.length <= limitActual && acc[acc.length - 1].documentId === document.quiddity.id) {
+          logger.info(`Duplicates in IR Search Results for DocumentId`, {
+            irTraceId: traceId,
+            document: JSON.stringify(document),
+            [MeltwaterAttributes.DOCUMENTID]: document.quiddity.id
+          });
+        }
+        return acc;
+      }, []);
+      logger.info(`Final Results Calculated, ${finalResults ? finalResults.length : 'no results'}`, {
+        irTraceId: traceId,
+        rune
+      });
+      return finalResults;
+      // original return function
+      // return result.body.views.searchResults.results.map(document => {
+      //     return document.quiddity;
+      // })
+    } catch (err) {
+      logger.error('Error executing search against Search Service', err, {
+        irTraceId: traceId,
+        rune
+      });
+    }
+  }
+  async latest(rune) {
+    let retryAttempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    try {
+      const result = await this.executeSearch(rune);
+      return result.body.views.searchResults.results.length && [result.body.views.searchResults.results[0].quiddity] || [];
+    } catch (err) {
+      retryAttempt++;
+      if (retryAttempt > this.RETRY_COUNT) {
+        logger.error(`Maximum Retrys hit for method latest ${err.status} ${err.message}`, err, {
+          [MeltwaterAttributes.COMPANYID]: this.company._id
+        });
+      } else if (await this.retryBecauseRateLimiting(err, 'latest')) {
+        return await this.latest(rune, retryAttempt);
+      }
+    }
+  }
+  async count(rune) {
+    try {
+      const result = await this.executeSearch(rune);
+      return result.body.views.documentCount.totalCount;
+    } catch (err) {
+      logger.error('Error getting count from Search Service', err);
+    }
+  }
+  async executeSearch(rune) {
+    await this.init();
+    this.addCompanyToRuneForHorace(rune);
+    const uri = `${this.searchServicesUrl}?apikey=${this.searchServicesKey}`;
+    return await superagent.post(uri).send(rune);
+  }
+  addCompanyToRuneForHorace(rune) {
+    if (!rune.metaData) {
+      rune.metaData = {};
+    }
+
+    // Horace requires this for tracking purposes
+    rune.metaData.companyId = this.company._id;
+  }
+  generateTraceId() {
+    return `engage_${this.company._id}_${this.traceId}_${v4()}`;
+  }
+}