@zohodesk/i18n 1.0.0-beta.38-murphy → 1.0.0-beta.39-murphy

package/es/utils/errorReporter.js

@@ -6,82 +6,58 @@ export const I18N_ERROR_TYPES = {
 const reportedKeys = new Set();
 const pendingErrors = new Map();
 const MAX_PENDING_ERRORS = 100;
+let hasLoggedQueueUse = false;
+let hasLoggedFlushUse = false;
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
-function isDebugEnabled() {
-  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
-}
-function debugLog(message, meta) {
-  if (!isDebugEnabled() || typeof console === 'undefined') {
-    return;
-  }
-  if (typeof console.log !== 'function') {
-    return;
-  }
-  if (typeof meta === 'undefined') {
-    console.log(`[i18n] ${message}`);
-  } else {
-    console.log(`[i18n] ${message}`, meta);
-  }
-}
 function sendToMurphy(type, key) {
-  debugLog('reporting i18n error', {
-    type,
-    key
-  });
   const error = new Error(`i18n ${type}: ${key}`);
   error.name = type;
-  murphy.error(error, undefined, {
+  const murphyOptions = {
     customTags: {
       errorType: type,
       i18nKey: key,
       category: 'i18n'
     },
     preventClientGrouping: true
-  });
+  };
+  try {
+    murphy.error(error, undefined, murphyOptions);
+  } catch (err) {
+    // Avoid throwing from error reporting
+  }
 }
 function queuePendingError(dedupeKey, type, key) {
   if (pendingErrors.has(dedupeKey)) {
-    debugLog('pending i18n error deduped', {
-      type,
-      key
-    });
     return;
   }
+  if (!hasLoggedQueueUse && typeof console !== 'undefined') {
+    console.log('[i18n] queued errors while murphy not available');
+    hasLoggedQueueUse = true;
+  }
   if (pendingErrors.size >= MAX_PENDING_ERRORS) {
     const oldestKey = pendingErrors.keys().next().value;
     pendingErrors.delete(oldestKey);
-    debugLog('pending i18n error dropped (queue full)', {
-      droppedKey: oldestKey,
-      pendingSize: pendingErrors.size
-    });
   }
   pendingErrors.set(dedupeKey, {
     type,
     key
   });
-  debugLog('queued i18n error (murphy not ready)', {
-    type,
-    key,
-    pendingSize: pendingErrors.size
-  });
 }
 export function flushI18NErrors() {
   if (!isMurphyAvailable()) {
-    debugLog('flush skipped (murphy not available)', {
-      pendingSize: pendingErrors.size
-    });
     return;
   }
   if (pendingErrors.size === 0) {
-    debugLog('flush skipped (no pending errors)');
     return;
   }
-  debugLog('flushing pending i18n errors', {
-    pendingSize: pendingErrors.size
-  });
-  let flushedCount = 0;
+  if (!hasLoggedFlushUse && typeof console !== 'undefined') {
+    console.log('[i18n] flushing queued errors', {
+      count: pendingErrors.size
+    });
+    hasLoggedFlushUse = true;
+  }
   for (const [dedupeKey, data] of pendingErrors) {
     if (reportedKeys.has(dedupeKey)) {
       pendingErrors.delete(dedupeKey);
@@ -90,40 +66,19 @@ export function flushI18NErrors() {
     sendToMurphy(data.type, data.key);
     reportedKeys.add(dedupeKey);
     pendingErrors.delete(dedupeKey);
-    flushedCount += 1;
   }
-  debugLog('flush complete', {
-    flushedCount,
-    pendingRemaining: pendingErrors.size
-  });
 }
 export function reportI18NError(type, key) {
-  debugLog('reportI18NError called', {
-    type,
-    key
-  });
   const dedupeKey = `${type}:${key}`;
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped', {
-      type,
-      key
-    });
     return;
   }
   if (!isMurphyAvailable()) {
-    debugLog('murphy not available, queueing i18n error', {
-      type,
-      key
-    });
     queuePendingError(dedupeKey, type, key);
     return;
   }
   flushI18NErrors();
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped after flush', {
-      type,
-      key
-    });
     return;
   }
   sendToMurphy(type, key);
@@ -132,7 +87,6 @@ export function reportI18NError(type, key) {
 export function clearReportedKeys() {
   reportedKeys.clear();
   pendingErrors.clear();
-  debugLog('cleared reported and pending i18n errors');
 }
 export function getFallbackText(key) {
   const isNumeric = /^\d+$/.test(key);

package/es/utils/index.js

@@ -244,7 +244,8 @@ export function getI18NValue(i18n) {
     let i18nStr = i18n[finalKey];
     if (i18nStr === undefined) {
       const isNumeric = /^\d+$/.test(finalKey);
-      reportI18NError(isNumeric ? I18N_ERROR_TYPES.NUMERIC_FALLBACK : I18N_ERROR_TYPES.MISSING_KEY, finalKey);
+      const errorType = isNumeric ? I18N_ERROR_TYPES.NUMERIC_FALLBACK : I18N_ERROR_TYPES.MISSING_KEY;
+      reportI18NError(errorType, finalKey);
       return localizedValue || getFallbackText(finalKey);
     }
     i18nStr = replaceI18NValuesWithRegex(i18nStr, values);

package/lib/utils/errorReporter.js

@@ -23,82 +23,58 @@ var I18N_ERROR_TYPES = exports.I18N_ERROR_TYPES = {
 var reportedKeys = new Set();
 var pendingErrors = new Map();
 var MAX_PENDING_ERRORS = 100;
+var hasLoggedQueueUse = false;
+var hasLoggedFlushUse = false;
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
-function isDebugEnabled() {
-  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
-}
-function debugLog(message, meta) {
-  if (!isDebugEnabled() || typeof console === 'undefined') {
-    return;
-  }
-  if (typeof console.log !== 'function') {
-    return;
-  }
-  if (typeof meta === 'undefined') {
-    console.log("[i18n] ".concat(message));
-  } else {
-    console.log("[i18n] ".concat(message), meta);
-  }
-}
 function sendToMurphy(type, key) {
-  debugLog('reporting i18n error', {
-    type: type,
-    key: key
-  });
   var error = new Error("i18n ".concat(type, ": ").concat(key));
   error.name = type;
-  murphy.error(error, undefined, {
+  var murphyOptions = {
     customTags: {
       errorType: type,
       i18nKey: key,
       category: 'i18n'
     },
     preventClientGrouping: true
-  });
+  };
+  try {
+    murphy.error(error, undefined, murphyOptions);
+  } catch (err) {
+    // Avoid throwing from error reporting
+  }
 }
 function queuePendingError(dedupeKey, type, key) {
   if (pendingErrors.has(dedupeKey)) {
-    debugLog('pending i18n error deduped', {
-      type: type,
-      key: key
-    });
     return;
   }
+  if (!hasLoggedQueueUse && typeof console !== 'undefined') {
+    console.log('[i18n] queued errors while murphy not available');
+    hasLoggedQueueUse = true;
+  }
   if (pendingErrors.size >= MAX_PENDING_ERRORS) {
     var oldestKey = pendingErrors.keys().next().value;
     pendingErrors["delete"](oldestKey);
-    debugLog('pending i18n error dropped (queue full)', {
-      droppedKey: oldestKey,
-      pendingSize: pendingErrors.size
-    });
   }
   pendingErrors.set(dedupeKey, {
     type: type,
     key: key
   });
-  debugLog('queued i18n error (murphy not ready)', {
-    type: type,
-    key: key,
-    pendingSize: pendingErrors.size
-  });
 }
 function flushI18NErrors() {
   if (!isMurphyAvailable()) {
-    debugLog('flush skipped (murphy not available)', {
-      pendingSize: pendingErrors.size
-    });
     return;
   }
   if (pendingErrors.size === 0) {
-    debugLog('flush skipped (no pending errors)');
     return;
   }
-  debugLog('flushing pending i18n errors', {
-    pendingSize: pendingErrors.size
-  });
-  var flushedCount = 0;
+  if (!hasLoggedFlushUse && typeof console !== 'undefined') {
+    console.log('[i18n] flushing queued errors', {
+      count: pendingErrors.size
+    });
+    hasLoggedFlushUse = true;
+  }
   var _iterator = _createForOfIteratorHelper(pendingErrors),
     _step;
   try {
@@ -113,45 +89,24 @@ function flushI18NErrors() {
       sendToMurphy(data.type, data.key);
       reportedKeys.add(dedupeKey);
       pendingErrors["delete"](dedupeKey);
-      flushedCount += 1;
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  debugLog('flush complete', {
-    flushedCount: flushedCount,
-    pendingRemaining: pendingErrors.size
-  });
 }
 function reportI18NError(type, key) {
-  debugLog('reportI18NError called', {
-    type: type,
-    key: key
-  });
   var dedupeKey = "".concat(type, ":").concat(key);
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped', {
-      type: type,
-      key: key
-    });
     return;
   }
   if (!isMurphyAvailable()) {
-    debugLog('murphy not available, queueing i18n error', {
-      type: type,
-      key: key
-    });
     queuePendingError(dedupeKey, type, key);
     return;
   }
   flushI18NErrors();
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped after flush', {
-      type: type,
-      key: key
-    });
     return;
   }
   sendToMurphy(type, key);
@@ -160,7 +115,6 @@ function reportI18NError(type, key) {
 function clearReportedKeys() {
   reportedKeys.clear();
   pendingErrors.clear();
-  debugLog('cleared reported and pending i18n errors');
 }
 function getFallbackText(key) {
   var isNumeric = /^\d+$/.test(key);

package/lib/utils/index.js

@@ -281,7 +281,8 @@ function getI18NValue(i18n) {
     var i18nStr = i18n[finalKey];
     if (i18nStr === undefined) {
       var isNumeric = /^\d+$/.test(finalKey);
-      (0, _errorReporter.reportI18NError)(isNumeric ? _errorReporter.I18N_ERROR_TYPES.NUMERIC_FALLBACK : _errorReporter.I18N_ERROR_TYPES.MISSING_KEY, finalKey);
+      var errorType = isNumeric ? _errorReporter.I18N_ERROR_TYPES.NUMERIC_FALLBACK : _errorReporter.I18N_ERROR_TYPES.MISSING_KEY;
+      (0, _errorReporter.reportI18NError)(errorType, finalKey);
       return localizedValue || (0, _errorReporter.getFallbackText)(finalKey);
     }
     i18nStr = replaceI18NValuesWithRegex(i18nStr, values);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/i18n",
-  "version": "1.0.0-beta.38-murphy",
+  "version": "1.0.0-beta.39-murphy",
   "main": "lib/index",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",

package/src/utils/errorReporter.js

@@ -7,129 +7,104 @@ export const I18N_ERROR_TYPES = {
 const reportedKeys = new Set();
 const pendingErrors = new Map();
 const MAX_PENDING_ERRORS = 100;
+let hasLoggedQueueUse = false;
+let hasLoggedFlushUse = false;
 
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
 
-function isDebugEnabled() {
-  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
-}
-
-function debugLog(message, meta) {
-  if (!isDebugEnabled() || typeof console === 'undefined') {
-    return;
-  }
-  if (typeof console.log !== 'function') {
-    return;
-  }
-  if (typeof meta === 'undefined') {
-    console.log(`[i18n] ${message}`);
-  } else {
-    console.log(`[i18n] ${message}`, meta);
-  }
-}
-
 function sendToMurphy(type, key) {
-  debugLog('reporting i18n error', { type, key });
   const error = new Error(`i18n ${type}: ${key}`);
   error.name = type;
 
-  murphy.error(error, undefined, {
+  const murphyOptions = {
     customTags: {
       errorType: type,
       i18nKey: key,
       category: 'i18n'
     },
     preventClientGrouping: true
-  });
+  };
+
+  try {
+    murphy.error(error, undefined, murphyOptions);
+  } catch (err) {
+    // Avoid throwing from error reporting
+  }
 }
 
 function queuePendingError(dedupeKey, type, key) {
   if (pendingErrors.has(dedupeKey)) {
-    debugLog('pending i18n error deduped', { type, key });
     return;
   }
 
+  if (!hasLoggedQueueUse && typeof console !== 'undefined') {
+    console.log('[i18n] queued errors while murphy not available');
+    hasLoggedQueueUse = true;
+  }
+
   if (pendingErrors.size >= MAX_PENDING_ERRORS) {
     const oldestKey = pendingErrors.keys().next().value;
     pendingErrors.delete(oldestKey);
-    debugLog('pending i18n error dropped (queue full)', {
-      droppedKey: oldestKey,
-      pendingSize: pendingErrors.size
-    });
   }
 
   pendingErrors.set(dedupeKey, { type, key });
-  debugLog('queued i18n error (murphy not ready)', {
-    type,
-    key,
-    pendingSize: pendingErrors.size
-  });
 }
 
 export function flushI18NErrors() {
   if (!isMurphyAvailable()) {
-    debugLog('flush skipped (murphy not available)', {
-      pendingSize: pendingErrors.size
-    });
     return;
   }
 
   if (pendingErrors.size === 0) {
-    debugLog('flush skipped (no pending errors)');
     return;
   }
 
-  debugLog('flushing pending i18n errors', {
-    pendingSize: pendingErrors.size
-  });
+  if (!hasLoggedFlushUse && typeof console !== 'undefined') {
+    console.log('[i18n] flushing queued errors', {
+      count: pendingErrors.size
+    });
+    hasLoggedFlushUse = true;
+  }
 
-  let flushedCount = 0;
   for (const [dedupeKey, data] of pendingErrors) {
     if (reportedKeys.has(dedupeKey)) {
       pendingErrors.delete(dedupeKey);
       continue;
     }
+
     sendToMurphy(data.type, data.key);
     reportedKeys.add(dedupeKey);
     pendingErrors.delete(dedupeKey);
-    flushedCount += 1;
   }
-
-  debugLog('flush complete', {
-    flushedCount,
-    pendingRemaining: pendingErrors.size
-  });
 }
 
 export function reportI18NError(type, key) {
-  debugLog('reportI18NError called', { type, key });
   const dedupeKey = `${type}:${key}`;
+
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped', { type, key });
     return;
   }
 
   if (!isMurphyAvailable()) {
-    debugLog('murphy not available, queueing i18n error', { type, key });
     queuePendingError(dedupeKey, type, key);
     return;
   }
 
   flushI18NErrors();
+
   if (reportedKeys.has(dedupeKey)) {
-    debugLog('reported i18n error deduped after flush', { type, key });
     return;
   }
 
   sendToMurphy(type, key);
   reportedKeys.add(dedupeKey);
 }
+
 export function clearReportedKeys() {
   reportedKeys.clear();
   pendingErrors.clear();
-  debugLog('cleared reported and pending i18n errors');
 }
 
 export function getFallbackText(key) {

package/src/utils/index.js

@@ -294,16 +294,21 @@ export function getI18NValue(i18n) {
     reportI18NError(I18N_ERROR_TYPES.UNDEFINED_OBJECT, 'i18n_object');
     return (key) => key;
   }
+
   return (key, values, localizedProps) => {
-    const localizedValue = localizedProps ? getLocalizedValue(localizedProps) : localizedStringData[key];
+    const localizedValue = localizedProps
+      ? getLocalizedValue(localizedProps)
+      : localizedStringData[key];
     const finalKey = getMappedKey(key);
     let i18nStr = i18n[finalKey];
+
     if (i18nStr === undefined) {
       const isNumeric = /^\d+$/.test(finalKey);
-      reportI18NError(
-        isNumeric ? I18N_ERROR_TYPES.NUMERIC_FALLBACK : I18N_ERROR_TYPES.MISSING_KEY,
-        finalKey
-      );
+      const errorType = isNumeric
+        ? I18N_ERROR_TYPES.NUMERIC_FALLBACK
+        : I18N_ERROR_TYPES.MISSING_KEY;
+
+      reportI18NError(errorType, finalKey);
       return localizedValue || getFallbackText(finalKey);
     }
     i18nStr = replaceI18NValuesWithRegex(i18nStr, values);