@meltwater/conversations-api-services 1.0.0

package/src/data-access/http/ir.client.js

@@ -0,0 +1,309 @@
+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';
+
+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}/`;
+
+        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) {
+            logger.error(
+                `Failed adding a revisions with operation:${JSON.stringify(
+                    operations
+                )}`,
+                { error, url, companyId: this.company._id, operations }
+            );
+            return;
+        }
+
+        logger.info(`Finished adding revision operations`, { operations });
+
+        return result;
+    }
+
+    async modifyDocuments(operations, retryAttempt = 0) {
+        await this.init();
+        const wait = 100;
+        const url = `${this.documentServiceUrl}/`;
+
+        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) {
+                logger.error(
+                    `Maximum Retrys hit for method modifyDocuments ${err.status} ${err.message}`,
+                    { err, companyId: this.company._id }
+                );
+            } else if (
+                await this.retryBecauseRateLimiting(err, 'modifyDocuments')
+            ) {
+                return await this.modifyDocuments(operations, retryAttempt);
+            }
+        }
+
+        logger.info(`Finished modifying documents operations`, { operations });
+
+        return result;
+    }
+
+    async getDocumentById(id, retryAttempt = 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, companyId: this.company._id }
+                );
+            } else if (
+                await this.retryBecauseRateLimiting(err, 'getDocumentById')
+            ) {
+                return await this.getDocumentById(id, retryAttempt);
+            }
+        }
+    }
+
+    async retryBecauseRateLimiting(err, name) {
+        // rate limit error
+        if (err.status === 429) {
+            this.metrics.count(metricNames.irRatelimited);
+            logger.error(
+                `Error Accessing ir.client method because rate limit: trying again ${name}`,
+                { err, companyId: this.company._id }
+            );
+            // 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) {
+            logger.info(
+                `Document Not Found ir.client method ${name} ${err.status} ${err.message}`,
+                { err, companyId: this.company._id }
+            );
+        } else {
+            logger.info(
+                `Could not access ir.client method ${name} ${err.status} ${err.message}`,
+                { err, companyId: this.company._id }
+            );
+        }
+        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 ` +
+                                document.quiddity.id,
+                            { document, irTraceId: traceId }
+                        );
+                    }
+                    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, retryAttempt = 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, 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()}`;
+    }
+}