@meltwater/conversations-api-services 1.3.1 → 1.4.0

package/src/data-access/http/linkedin.native.js

@@ -1,5 +1,5 @@
 import superagent from 'superagent';
-import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+import { loggerDebug, loggerInfo, MeltwaterAttributes } from '../../lib/logger.helpers.js';
 
 
 const LINKEDIN_API = "https://api.linkedin.com/v2";
@@ -33,7 +33,13 @@ export async function like(token, externalId, socialAccountId, logger) {
             { response: JSON.stringify(response) }
         );
     } catch (err) {
-        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        loggerInfo(logger, `Failed to call linkedin api - like`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                socialAccountId,
+                error: err?.message,
+            }),
+        });
         throw err;
     }
     return response.connection || response;
@@ -67,7 +73,13 @@ export async function unlike(token, externalId, socialAccountId, logger) {
             { response: JSON.stringify(response) }
         );
     } catch (err) {
-        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        loggerInfo(logger, `Failed to call linkedin api - unlike`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                socialAccountId,
+                error: err?.message,
+            }),
+        });
         throw err;
     }
     return response.connection || response;
@@ -101,8 +113,14 @@ export async function deleteMessage(token, externalId, sourceId, inReplyToId, lo
             { response: JSON.stringify(response) }
         );
     } catch (err) {
-        loggerError(logger,`Linkedin Delete exception details`, {
-            err,
+        loggerInfo(logger, `Failed to call linkedin api - deleteMessage`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                commentId,
+                inReplyToId,
+                sourceId,
+                error: err?.message,
+            }),
         });
         throw err;
     }
@@ -264,10 +282,14 @@ async function publish(token,discussionType, mediaId,inReplyToId,socialAccountId
         }
         
     } catch (err) {
-        loggerError(logger,
-            `Exception in linkedin publish `,
-            err
-        );
+        loggerInfo(logger, `Failed to call linkedin api - publish`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                inReplyToId,
+                discussionType,
+                socialAccountId,
+                error: err?.response?.body?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
@@ -297,17 +319,25 @@ async function getImageMedia(mediaId, token, logger) {
                 'LinkedIn-Version': LINKEDIN_VERSION,
             });
     } catch (error) {
-        loggerError(logger,'Error in getImageMedia', error);
+        loggerInfo(logger, `Failed to call linkedin api - getImageMedia`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                mediaId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 
     let { downloadUrl } = response.body || {};
     if (downloadUrl) {
         return { downloadUrl };
     } else {
-        loggerError(logger,
-            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
-            { response: JSON.stringify(response) }
-        );
+        loggerInfo(logger, `Failed to call linkedin api - getImageMedia bad status`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                mediaId,
+                responseBody: response.body,
+            }),
+        });
         return {};
     }
 }
@@ -346,17 +376,25 @@ export async function getVideoMedia(mediaId, token, logger) {
                 'LinkedIn-Version': LINKEDIN_VERSION,
             });
     } catch (error) {
-        loggerError(logger, 'Error in getVideoMedia', error);
+        loggerInfo(logger, `Failed to call linkedin api - getVideoMedia`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                mediaId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 
     let { thumbnail, downloadUrl } = response.body || {};
     if (downloadUrl) {
         return { thumbnail, downloadUrl };
     } else {
-        loggerError(logger,
-            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
-            { response: JSON.stringify(response) }
-        );
+        loggerInfo(logger, `Failed to call linkedin api - getVideoMedia bad status`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                mediaId,
+                responseBody: response.body,
+            }),
+        });
         return {};
     }
 }
@@ -367,34 +405,30 @@ export async function getMedia(token, mediaId, type, logger) {
         type = 'image/jpeg';
     }
 
-    try {
-        if (type.includes('image')) {
-            const { downloadUrl } = await getImageMedia(
-                mediaId,
-                token,
-                logger
-            );
-
-            return {
-                downloadUrl,
-            };
-        } else if (type.includes('video')) {
-            const { thumbnail, downloadUrl } = await getVideoMedia(
-                mediaId,
-                token,
-                logger
-            );
+    if (type.includes('image')) {
+        const { downloadUrl } = await getImageMedia(
+            mediaId,
+            token,
+            logger
+        );
 
-            return {
-                thumbnail,
-                downloadUrl,
-            };
-        }
+        return {
+            downloadUrl,
+        };
+    } else if (type.includes('video')) {
+        const { thumbnail, downloadUrl } = await getVideoMedia(
+            mediaId,
+            token,
+            logger
+        );
 
-        return {};
-    } catch (error) {
-        loggerError(logger,'Error in getMedia', error);
+        return {
+            thumbnail,
+            downloadUrl,
+        };
     }
+
+    return {};
 }
 
 export async function mediaUploadURL(
@@ -428,10 +462,13 @@ export async function mediaUploadURL(
         };
         return response;
     } catch (err) {
-        loggerError(logger,
-            `Exception linkedin media register `,
-            err
-        );
+        loggerInfo(logger, `Failed to call linkedin api - mediaUploadURL`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                socialAccountId,
+                error: err?.response?.body?.message ?? err?.message,
+            }),
+        });
+        throw err;
     }
 }
 
@@ -454,11 +491,13 @@ export async function getProfile(urn, token, logger) {
             })
             .then((result) => result.body);
     } catch (error) {
-        loggerError(logger,
-            `Failed requesting LinkedIn API for profileId ${urn}`,
-            error
-        );
-        return;
+        loggerInfo(logger, `Failed to call linkedin api - getProfile`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                urn,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 
     loggerInfo( logger,
@@ -492,10 +531,13 @@ export async function getOrganization(urn, token, logger) {
             return { id: 'private' };
         }
 
-        loggerError(logger,
-            `Failed requesting LinkedIn API for organizationId ${urn}`,
-            error
-        );
+        loggerInfo(logger, `Failed to call linkedin api - getOrganization`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                urn,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
     loggerInfo(logger,
         `Finished requesting LinkedIn API for organizationId ${urn}`
@@ -517,7 +559,13 @@ export async function getMediaFromUrl(token, url, logger) {
 
         return response;
     } catch (error) {
-        loggerError(logger,'Error in getMediaFromUrl', error);
+        loggerInfo(logger, `Failed to call linkedin api - getMediaFromUrl`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                url,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
@@ -540,10 +588,14 @@ export async function getOrganizations(urn, token, logger) {
                 return res.results[id];
             });
     } catch (error) {
-        loggerError(logger,
-            `Failed requesting LinkedIn API for organization id ${id}`,
-            error
-        );
+        loggerInfo(logger, `Failed to call linkedin api - getOrganizations`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                urn,
+                id,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 
     loggerInfo(logger,
@@ -570,37 +622,41 @@ async function getAllStats(externalId, token, logger) {
                 'LinkedIn-Version': LINKEDIN_VERSION,
             });
     } catch (error) {
-        loggerError(logger,'Error in getAllStats', error);
+        loggerInfo(logger, `Failed to call linkedin api - getAllStats`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 
     let { commentSummary, reactionSummaries } = response.body || {};
     if (commentSummary && reactionSummaries) {
         return { commentSummary, reactionSummaries };
     } else {
-        loggerError( logger,
-            `Invalid response getting all Linkedin Stats for externalId: ${externalId}`,
-            { response: JSON.stringify(response) }
-        );
+        loggerInfo(logger, `Failed to call linkedin api - getAllStats bad status`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                responseBody: response.body,
+            }),
+        });
         return {};
     }
 }
 
 export async function getSocialStats(externalId, token, logger) {
-    try {
-        // get all stats (likes are not to be trusted) seems to only work
-        // for og posts.
-        const {
-            commentSummary,
-            reactionSummaries,
-        } = await getAllStats(externalId, token, logger);
-
-        return {
-            commentSummary,
-            reactionSummaries,
-        };
-    } catch (error) {
-        loggerError(logger,'Error in getSocialStats', error);
-    }
+    // get all stats (likes are not to be trusted) seems to only work
+    // for og posts.
+    const {
+        commentSummary,
+        reactionSummaries,
+    } = await getAllStats(externalId, token, logger);
+
+    return {
+        commentSummary,
+        reactionSummaries,
+    };
 }
 
 export async function likedByUser(
@@ -644,7 +700,12 @@ export async function uploadMedia(query, logger) {
         })
         .send(data)
         .catch((err) => {
-            loggerError(logger,"Linkedin Error uploading Media",err);
+            loggerInfo(logger, `Failed to call linkedin api - uploadMedia`, {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    url,
+                    error: err?.message,
+                }),
+            });
             throw err;
         });
 }

package/src/data-access/http/threads.native.js

@@ -2,8 +2,8 @@ import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
 import {
     loggerDebug,
-    loggerError,
     loggerInfo,
+    MeltwaterAttributes,
 } from '../../lib/logger.helpers.js';
 
 const THREADS_URL = 'https://graph.threads.net/v1.0';
@@ -86,11 +86,12 @@ async function confirmCreationId(accessToken, creationId, logger) {
             logger
         );
     } catch (error) {
-        loggerError(
-            logger,
-            `Creation ID ${creationId} confirmation failed: ${error.message}`,
-            error
-        );
+        loggerInfo(logger, `Failed to call threads api - confirmCreationId`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                creationId,
+                error: error?.message,
+            }),
+        });
         error.code = 408; // Request Timeout
         throw error;
     }
@@ -105,25 +106,37 @@ async function confirmCreationId(accessToken, creationId, logger) {
  * @throws {Error} If the request fails.
  */
 async function sendRequest(apiUrl, params, logger) {
+    let response;
     try {
-        const response = await superagent
+        response = await superagent
             .get(apiUrl)
             .set('Accept', 'application/json')
             .set('Content-Type', 'application/json')
             .query(params)
             .send();
-
-        if (response.status !== 200) {
-            throw new Error(`Unexpected response status: ${response.status}`);
-        }
-
-        loggerDebug(logger, 'Threads Response status', response.status);
-        return response;
     } catch (err) {
-        const errorMessage = err?.response?.body?.error?.message || err.message;
-        loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+        loggerInfo(logger, `Failed to call threads api - sendRequest`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
+
+    if (response.status !== 200) {
+        loggerInfo(logger, `Failed to call threads api - sendRequest bad status`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: response.status,
+                responseBody: response.body,
+            }),
+        });
+        throw new Error(`Unexpected response status: ${response.status}`);
+    }
+
+    loggerDebug(logger, 'Threads Response status', response.status);
+    return response;
 }
 
 /**
@@ -135,25 +148,37 @@ async function sendRequest(apiUrl, params, logger) {
  * @throws {Error} If the request fails.
  */
 async function requestApi(apiUrl, params, logger) {
+    let response;
     try {
-        const response = await superagent
+        response = await superagent
             .post(apiUrl)
             .set('Accept', 'application/json')
             .set('Content-Type', 'application/json')
             .query(params)
             .send();
-
-        if (response.status !== 200) {
-            throw new Error(`Unexpected response status: ${response.status}`);
-        }
-
-        loggerDebug(logger, 'Threads Response status', response.status);
-        return response;
     } catch (err) {
-        const errorMessage = err?.response?.body?.error?.message || err.message;
-        loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+        loggerInfo(logger, `Failed to call threads api - requestApi`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
+
+    if (response.status !== 200) {
+        loggerInfo(logger, `Failed to call threads api - requestApi bad status`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: response.status,
+                responseBody: response.body,
+            }),
+        });
+        throw new Error(`Unexpected response status: ${response.status}`);
+    }
+
+    loggerDebug(logger, 'Threads Response status', response.status);
+    return response;
 }
 
 /**
@@ -355,7 +380,13 @@ async function constructReplyQuery(
 
         return { ...query, creation_id: containerResponse.body.id };
     } catch (error) {
-        loggerError(logger, 'Error constructing reply query', error);
+        loggerInfo(logger, `Failed to call threads api - constructReplyQuery`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                inReplyToId,
+                isQuote,
+                error: error?.message,
+            }),
+        });
         throw error;
     }
 }

package/src/data-access/http/tiktok.native.js

@@ -1,5 +1,5 @@
 import superagent from 'superagent';
-import { loggerError, MeltwaterAttributes } from '../../lib/logger.helpers.js';
+import { loggerInfo, MeltwaterAttributes } from '../../lib/logger.helpers.js';
 import { removePrefix } from '../../lib/externalId.helpers.js';
 
 const TIKTOK_API_URL =
@@ -244,30 +244,22 @@ async function sendRequest(token, paramString = '', logger) {
             .set('Access-Token', token)
             .send();
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(
-                logger,
-                `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(
-                logger,
-                `Failed to call tiktok api for paramString ${paramString}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, 'Failed to call tiktok api - sendRequest', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger, `Failed to call tiktok api`, {
-            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify(response.body),
+        loggerInfo(logger, 'Failed to call tiktok api - sendRequest', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                status: response.status,
+                body: response.body,
+            }),
         });
         let error = new Error(`Failed to call tiktok api`);
         error.code = response.status;
@@ -287,24 +279,12 @@ async function sendPost(token, paramString = '', postData = undefined, logger) {
             .set('Access-Token', token)
             .send(postData);
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(
-                logger,
-                `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(
-                logger,
-                `Failed to call tiktok api for paramString ${paramString}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, 'Failed to call tiktok api - sendPost', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }