playov2-js-utilities 0.3.70 → 0.3.73

package/lib/logger.js

@@ -1,115 +1,115 @@
-const PLAYO_LOGGER = require("@playo/logger")
-
-const LOGGER = new PLAYO_LOGGER("playov2-js-utilities")
-
-const ENV = process.env.NODE_ENV || 'staging';
-
-if (ENV === 'staging' || ENV === 'test') {
-    LOGGER.setSlack('# test');
-}
-
-if (ENV === "production") {
-    LOGGER.setMailer({
-        'receiverEmail': ["saurabh@playo.co", "avish@playo.co"], // array of recievers, mandatory
-        'senderEmail': "logger@playo.co",// address of sender, mandatory
-        'senderName': 'Mail Logger - prod - Utitlies module', // default: Mail Logger, optional
-        'replyEmail': 'no-reply@mail.com', // default: no-reply@playo.co, optional
-        'region': "us-east-1", // default: 'us-east-1', optional
-    });
-
-    LOGGER.setSlack('# server_alerts');
-};
-
-/**
- * Info log - use where some stack trace needs to be stored for later debug purpose
- * @param {String} id
- * @param {Object} data
- * @param {String} message
- */
-const prepareInfoLog = (
-    id = "info-log",
-    data = {},
-    message = "info-message"
-) => {
-    LOGGER.info(id, data, message);
-};
-
-/**
- * Error log - used to monitor error throughout the system
- * @param {String} id
- * @param {Object} data
- * @param {String} message
- */
-const prepareErrorLog = (
-    id = "error-log",
-    data = {},
-    message = "error-message"
-) => {
-    if (data.stack) {
-        data = data.stack;
-    }
-    LOGGER.error(id, data, message);
-};
-
-/**
- * Alert log - Sends alert on slack and email to notify to concerned people
- * @param {String} id
- * @param {Object} data
- * @param {String} message
- * @param {Boolean} sendEmail
- */
-const prepareAlertLog = (
-    id = "alert-log",
-    data = {},
-    message = "alert-message",
-    sendEmail = false
-) => {
-    LOGGER.alert(id, data, message, sendEmail);
-};
-
-/**
- * Use this to debug , ideally only on staging env
- * @param {String} id
- * @param {Object} data
- * @param {String} message
- */
-const prepareDebugLog = (
-    id = "alert log",
-    data = {},
-    message = "debug-log"
-) => {
-    LOGGER.debug(id, data, message);
-};
-
-/**
- * Use this to print error or failure that do not need to fixed on an urgent basis but need to later analyzed later
- * @param {String} id
- * @param {Object} data
- * @param {String} message
- */
-const prepareWarnLog = (
-    id = "warn log",
-    data = {},
-    message = "warn-log",
-    topic = 'warn-topic'
-) => {
-    LOGGER.warn(id, data, message, topic);
-};
-
-/**
- * Set module name for your module to be observed in logs
- * @param {String} moduleName
- * @returns
- */
-const setModule = (moduleName) => {
-    return LOGGER.setModule(moduleName);
-};
-
-module.exports = {
-    prepareInfoLog,
-    prepareErrorLog,
-    prepareAlertLog,
-    prepareDebugLog,
-    prepareWarnLog,
-    setModule,
-};
+const PLAYO_LOGGER = require("@playo/logger")
+
+const LOGGER = new PLAYO_LOGGER("playov2-js-utilities")
+
+const ENV = process.env.NODE_ENV || 'staging';
+
+if (ENV === 'staging' || ENV === 'test') {
+    LOGGER.setSlack('# test');
+}
+
+if (ENV === "production") {
+    LOGGER.setMailer({
+        'receiverEmail': ["saurabh@playo.co", "avish@playo.co"], // array of recievers, mandatory
+        'senderEmail': "logger@playo.co",// address of sender, mandatory
+        'senderName': 'Mail Logger - prod - Utitlies module', // default: Mail Logger, optional
+        'replyEmail': 'no-reply@mail.com', // default: no-reply@playo.co, optional
+        'region': "us-east-1", // default: 'us-east-1', optional
+    });
+
+    LOGGER.setSlack('# server_alerts');
+};
+
+/**
+ * Info log - use where some stack trace needs to be stored for later debug purpose
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} message
+ */
+const prepareInfoLog = (
+    id = "info-log",
+    data = {},
+    message = "info-message"
+) => {
+    LOGGER.info(id, data, message);
+};
+
+/**
+ * Error log - used to monitor error throughout the system
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} message
+ */
+const prepareErrorLog = (
+    id = "error-log",
+    data = {},
+    message = "error-message"
+) => {
+    if (data.stack) {
+        data = data.stack;
+    }
+    LOGGER.error(id, data, message);
+};
+
+/**
+ * Alert log - Sends alert on slack and email to notify to concerned people
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} message
+ * @param {Boolean} sendEmail
+ */
+const prepareAlertLog = (
+    id = "alert-log",
+    data = {},
+    message = "alert-message",
+    sendEmail = false
+) => {
+    LOGGER.alert(id, data, message, sendEmail);
+};
+
+/**
+ * Use this to debug , ideally only on staging env
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} message
+ */
+const prepareDebugLog = (
+    id = "alert log",
+    data = {},
+    message = "debug-log"
+) => {
+    LOGGER.debug(id, data, message);
+};
+
+/**
+ * Use this to print error or failure that do not need to fixed on an urgent basis but need to later analyzed later
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} message
+ */
+const prepareWarnLog = (
+    id = "warn log",
+    data = {},
+    message = "warn-log",
+    topic = 'warn-topic'
+) => {
+    LOGGER.warn(id, data, message, topic);
+};
+
+/**
+ * Set module name for your module to be observed in logs
+ * @param {String} moduleName
+ * @returns
+ */
+const setModule = (moduleName) => {
+    return LOGGER.setModule(moduleName);
+};
+
+module.exports = {
+    prepareInfoLog,
+    prepareErrorLog,
+    prepareAlertLog,
+    prepareDebugLog,
+    prepareWarnLog,
+    setModule,
+};

package/lib/message_publisher/index.js

@@ -1,145 +1,145 @@
-/*
- Read this and associated queue configs before deploying a new queue
- https://cloud.google.com/tasks/docs/reference/rest/v2beta3/projects.locations.queues.tasks#resource:-task
-*/
-
-const { CloudTasksClient } = require('@google-cloud/tasks');
-const { v4: uuidv4 } = require('uuid');
-
-const PLAYO_LOGGER = require("@playo/logger");
-const LOGGER = new PLAYO_LOGGER("playo-message-publisher");
-
-const client = new CloudTasksClient();
-
-const PROJECT = process.env.GCP_PROJECT;
-const LOCATION = process.env.GCP_LOCATION;
-
-if (!PROJECT || !LOCATION) {
-    console.warn('You need to pass - GCP_PROJECT, GCP_LOCATION in env for message queue to work!');
-}
-
-const { google } = require('googleapis');
-const cloudtasks = google.cloudtasks('v2');
-
-/**
- *
- * @param {String} queueId - Name of the queue being targeted
- * @param {Object} payload - {
- *                              httpMethod: String <POST, GET, PUT>
- *                              url: String,
- *                              headers: Object,
- *                              body: Object, // not needed if GET request
- *                              ttl: Optional, date in utc format, consumer will check if the ttl has been exceeded or not and then will respond accordingly
- *                              ...
- *                                                       
- *                           }
- * @param {Object} messageProcessingProperties - {
- *                                                  delay 
- *                                                }
- * @param {String} taskId -used as de-duplication key
- * @param {String} requestId 
- * @returns {}
- */
-async function createHttpTask(queueId, payload, messageProcessingProperties, taskId, requestId) {
-
-    try {
-        const project = PROJECT;
-        const queue = queueId;
-        const location = LOCATION;
-
-        const { delay = 0 } = messageProcessingProperties
-
-        const parent = client.queuePath(project, location, queue);
-
-        const task = {
-            httpRequest: payload,
-            name: ''
-        };
-
-        task.name = getTaskId(project, location, queue, taskId);
-
-        if (payload.body) {
-            task.httpRequest.body = Buffer.from(payload.body).toString('base64');
-        }
-
-        if (delay) {
-            // The time when the task is scheduled to be attempted.
-            task.scheduleTime = {
-                seconds: delay + Date.now() / 1000,
-            };
-        };
-
-        LOGGER.info(requestId, task, `Sending task to queue ${queueId}}`)
-
-        const request = { parent: parent, task: task };
-        const [response] = await client.createTask(request);
-
-        LOGGER.info(requestId, { name: response.name, response }, `Added task to queue ${queueId}}`);
-        return response;
-    } catch (err) {
-        if (err && err.code === 6) { // Idempotent request - assume sucess when the task being tried to save is already there!
-            return Promise.resolve('success!');
-        }
-        throw err;
-    }
-};
-
-/**
- * Returns a unique string for name of a task in task queues, to be used for task de-duplication purpose.
- * @param {String} projectId 
- * @param {String} locationId 
- * @param {String} queueId 
- * @param {String} taskId 
- * @returns {String}
- */
-const getTaskId = (projectId, locationId, queueId, taskId = uuidv4()) => {
-    return `projects/${projectId}/locations/${locationId}/queues/${queueId}/tasks/${taskId}`;
-};
-
-let authClient;
-/**
- * https://cloud.google.com/tasks/docs/reference/rest/v2/projects.locations.queues.tasks/delete
- * 
- */
-
-(async () => {
-    authClient = await authorize();
-})();
-
-const deleteHttpTask = async (queueId, taskId) => {
-    if (!queueId || !taskId) {
-        throw new Error('Both queueId, and taskId are required to delete a task!;')
-    }
-    const requestData = {
-        name: getTaskId(PROJECT, LOCATION, queueId, taskId),
-        auth: authClient
-    };
-
-    try {
-        await cloudtasks.projects.locations.queues.tasks.delete(requestData);
-    } catch (err) {
-        /*
-         Error response schema - 
-         Naturally if GCP response is that task didn't exist while we were trying to delete it, then we should not 
-         pass back the error to calle function and resume operations as normal. As delete operation is atomic and idempotent.
-         */
-        if (err.response.data && err.response.data.error && err.response.data.error.message === 'Requested entity was not found.') {
-            return Promise.resolve('success!');
-        }
-
-        throw err;
-    }
-};
-
-async function authorize() {
-    const auth = new google.auth.GoogleAuth({
-        scopes: ['https://www.googleapis.com/auth/cloud-platform']
-    });
-    return await auth.getClient();
-};
-
-module.exports = {
-    createHttpTask,
-    getTaskId,
-    deleteHttpTask
+/*
+ Read this and associated queue configs before deploying a new queue
+ https://cloud.google.com/tasks/docs/reference/rest/v2beta3/projects.locations.queues.tasks#resource:-task
+*/
+
+const { CloudTasksClient } = require('@google-cloud/tasks');
+const { v4: uuidv4 } = require('uuid');
+
+const PLAYO_LOGGER = require("@playo/logger");
+const LOGGER = new PLAYO_LOGGER("playo-message-publisher");
+
+const client = new CloudTasksClient();
+
+const PROJECT = process.env.GCP_PROJECT;
+const LOCATION = process.env.GCP_LOCATION;
+
+if (!PROJECT || !LOCATION) {
+    console.warn('You need to pass - GCP_PROJECT, GCP_LOCATION in env for message queue to work!');
+}
+
+const { google } = require('googleapis');
+const cloudtasks = google.cloudtasks('v2');
+
+/**
+ *
+ * @param {String} queueId - Name of the queue being targeted
+ * @param {Object} payload - {
+ *                              httpMethod: String <POST, GET, PUT>
+ *                              url: String,
+ *                              headers: Object,
+ *                              body: Object, // not needed if GET request
+ *                              ttl: Optional, date in utc format, consumer will check if the ttl has been exceeded or not and then will respond accordingly
+ *                              ...
+ *                                                       
+ *                           }
+ * @param {Object} messageProcessingProperties - {
+ *                                                  delay 
+ *                                                }
+ * @param {String} taskId -used as de-duplication key
+ * @param {String} requestId 
+ * @returns {}
+ */
+async function createHttpTask(queueId, payload, messageProcessingProperties, taskId, requestId) {
+
+    try {
+        const project = PROJECT;
+        const queue = queueId;
+        const location = LOCATION;
+
+        const { delay = 0 } = messageProcessingProperties
+
+        const parent = client.queuePath(project, location, queue);
+
+        const task = {
+            httpRequest: payload,
+            name: ''
+        };
+
+        task.name = getTaskId(project, location, queue, taskId);
+
+        if (payload.body) {
+            task.httpRequest.body = Buffer.from(payload.body).toString('base64');
+        }
+
+        if (delay) {
+            // The time when the task is scheduled to be attempted.
+            task.scheduleTime = {
+                seconds: delay + Date.now() / 1000,
+            };
+        };
+
+        LOGGER.info(requestId, task, `Sending task to queue ${queueId}}`)
+
+        const request = { parent: parent, task: task };
+        const [response] = await client.createTask(request);
+
+        LOGGER.info(requestId, { name: response.name, response }, `Added task to queue ${queueId}}`);
+        return response;
+    } catch (err) {
+        if (err && err.code === 6) { // Idempotent request - assume sucess when the task being tried to save is already there!
+            return Promise.resolve('success!');
+        }
+        throw err;
+    }
+};
+
+/**
+ * Returns a unique string for name of a task in task queues, to be used for task de-duplication purpose.
+ * @param {String} projectId 
+ * @param {String} locationId 
+ * @param {String} queueId 
+ * @param {String} taskId 
+ * @returns {String}
+ */
+const getTaskId = (projectId, locationId, queueId, taskId = uuidv4()) => {
+    return `projects/${projectId}/locations/${locationId}/queues/${queueId}/tasks/${taskId}`;
+};
+
+let authClient;
+/**
+ * https://cloud.google.com/tasks/docs/reference/rest/v2/projects.locations.queues.tasks/delete
+ * 
+ */
+
+(async () => {
+    authClient = await authorize();
+})();
+
+const deleteHttpTask = async (queueId, taskId) => {
+    if (!queueId || !taskId) {
+        throw new Error('Both queueId, and taskId are required to delete a task!;')
+    }
+    const requestData = {
+        name: getTaskId(PROJECT, LOCATION, queueId, taskId),
+        auth: authClient
+    };
+
+    try {
+        await cloudtasks.projects.locations.queues.tasks.delete(requestData);
+    } catch (err) {
+        /*
+         Error response schema - 
+         Naturally if GCP response is that task didn't exist while we were trying to delete it, then we should not 
+         pass back the error to calle function and resume operations as normal. As delete operation is atomic and idempotent.
+         */
+        if (err.response.data && err.response.data.error && err.response.data.error.message === 'Requested entity was not found.') {
+            return Promise.resolve('success!');
+        }
+
+        throw err;
+    }
+};
+
+async function authorize() {
+    const auth = new google.auth.GoogleAuth({
+        scopes: ['https://www.googleapis.com/auth/cloud-platform']
+    });
+    return await auth.getClient();
+};
+
+module.exports = {
+    createHttpTask,
+    getTaskId,
+    deleteHttpTask
 };

package/lib/middleware.js

@@ -1,47 +1,47 @@
-
-const { v4: uuidv4 } = require('uuid');
-const Logger = require('./logger')
-
-const playoServiceRequestInterceptor = (req, res, next, service = 'microservice-name') => {
-    const id = req.headers["x-request-id"] || uuidv4();
-    const start = Date.now();
-    let userId = 'internal-request';
-    if (req.headers.userinfo) {
-        try {
-            userId = JSON.parse(req.headers.userinfo).userId
-        } catch (error) {
-            Logger.prepareInfoLog(id, { userinfo: req.headers.userinfo }, "Malformed userInfo in headers detected");
-        }
-    }
-    const url = req.url;
-    const requestDetails = {
-        method: req.method,
-        params: req.params,
-        query: req.query,
-        url,
-        originalUrl: req.originalUrl,
-        service
-    };
-    if (req.body && JSON.stringify(req.body).length < 10000) { // 0.1 mb
-        requestDetails['body'] = req.body || {};
-    }
-
-    Logger.prepareInfoLog(id, requestDetails, "Incoming request");
-
-    res.on('finish', function () {
-        const duration = Date.now() - start;
-        const status = res.statusCode;
-        Logger.prepareInfoLog(id, { status, duration, service, url, userId }, "Outgoing request - finish event");
-    });
-
-    res.on('close', function () {
-        const duration = Date.now() - start;
-        const status = res.statusCode;
-        Logger.prepareInfoLog(id, { status, duration, service, url, userId }, "Outgoing request - close event");
-    });
-    next();
-};
-
-module.exports = {
-    playoServiceRequestInterceptor
+
+const { v4: uuidv4 } = require('uuid');
+const Logger = require('./logger')
+
+const playoServiceRequestInterceptor = (req, res, next, service = 'microservice-name') => {
+    const id = req.headers["x-request-id"] || uuidv4();
+    const start = Date.now();
+    let userId = 'internal-request';
+    if (req.headers.userinfo) {
+        try {
+            userId = JSON.parse(req.headers.userinfo).userId
+        } catch (error) {
+            Logger.prepareInfoLog(id, { userinfo: req.headers.userinfo }, "Malformed userInfo in headers detected");
+        }
+    }
+    const url = req.url;
+    const requestDetails = {
+        method: req.method,
+        params: req.params,
+        query: req.query,
+        url,
+        originalUrl: req.originalUrl,
+        service
+    };
+    if (req.body && JSON.stringify(req.body).length < 10000) { // 0.1 mb
+        requestDetails['body'] = req.body || {};
+    }
+
+    Logger.prepareInfoLog(id, requestDetails, "Incoming request");
+
+    res.on('finish', function () {
+        const duration = Date.now() - start;
+        const status = res.statusCode;
+        Logger.prepareInfoLog(id, { status, duration, service, url, userId }, "Outgoing request - finish event");
+    });
+
+    res.on('close', function () {
+        const duration = Date.now() - start;
+        const status = res.statusCode;
+        Logger.prepareInfoLog(id, { status, duration, service, url, userId }, "Outgoing request - close event");
+    });
+    next();
+};
+
+module.exports = {
+    playoServiceRequestInterceptor
 }