@cloudcare/browser-core 1.0.16 → 1.0.19

package/cjs/configuration.js

@@ -91,6 +91,7 @@ function commonInit(userConfiguration, buildEnv) {
     applicationId: userConfiguration.applicationId,
     env: userConfiguration.env || '',
     version: userConfiguration.version || '',
+    service: userConfiguration.service || 'browser',
     sdkVersion: buildEnv.sdkVersion,
     sdkName: buildEnv.sdkName,
     datakitUrl: getDatakitUrl(userConfiguration.datakitUrl || userConfiguration.datakitOrigin),
@@ -150,5 +151,23 @@ function mustUseSecureCookie(userConfiguration) {
 }
 
 function isIntakeRequest(url, configuration) {
-  return (0, _urlPolyfill.haveSameOrigin)(url, configuration.datakitUrl);
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl];
+
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint);
+  }
+
+  var isIntake = false;
+
+  for (var _i = 0, _notTakeRequest = notTakeRequest; _i < _notTakeRequest.length; _i++) {
+    var _url = _notTakeRequest[_i];
+
+    if (url.indexOf(_url) === 0) {
+      isIntake = true;
+      break;
+    }
+  }
+
+  return isIntake;
 }

package/cjs/dataMap.js

@@ -102,6 +102,7 @@ var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
+      error_handling: 'error.handling',
       resource_url: 'error.resource.url',
       resource_url_host: 'error.resource.url_host',
       resource_url_path: 'error.resource.url_path',

package/cjs/errorCollection.js

@@ -46,14 +46,16 @@ function startConsoleTracking(errorObservable) {
 
   console.error = function () {
     originalConsoleError.apply(console, arguments);
-    errorObservable.notify((0, _tools.extend)({}, buildErrorFromParams((0, _tools.toArray)(arguments)), {
+    var handlingStack = (0, _errorTools.createHandlingStack)();
+    errorObservable.notify((0, _tools.extend)({}, buildErrorFromParams((0, _tools.toArray)(arguments), handlingStack), {
       source: _errorTools.ErrorSource.CONSOLE,
-      startClocks: (0, _tools.clocksNow)()
+      startClocks: (0, _tools.clocksNow)(),
+      handling: _enums.ErrorHandling.HANDLED
     }));
   };
 }
 
-function buildErrorFromParams(params) {
+function buildErrorFromParams(params, handlingStack) {
   var firstErrorParam = (0, _tools.find)(params, function (param) {
     return param instanceof Error;
   });
@@ -63,7 +65,8 @@ function buildErrorFromParams(params) {
   }).join(' ');
   return {
     message: message,
-    stack: firstErrorParam ? (0, _errorTools.toStackTraceString)((0, _tracekit.computeStackTrace)(firstErrorParam)) : undefined
+    stack: firstErrorParam ? (0, _errorTools.toStackTraceString)((0, _tracekit.computeStackTrace)(firstErrorParam)) : undefined,
+    handlingStack: handlingStack
   };
 }
 
@@ -93,7 +96,8 @@ function startRuntimeErrorTracking(errorObservable) {
       stack: error.stack,
       type: error.type,
       source: _errorTools.ErrorSource.SOURCE,
-      startClocks: (0, _tools.clocksNow)()
+      startClocks: (0, _tools.clocksNow)(),
+      handling: _enums.ErrorHandling.UNHANDLED
     });
   };
 

package/cjs/helper/errorTools.js

@@ -4,12 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.formatUnknownError = formatUnknownError;
+exports.createHandlingStack = createHandlingStack;
 exports.toStackTraceString = toStackTraceString;
 exports.formatErrorMessage = formatErrorMessage;
 exports.ErrorSource = void 0;
 
 var _tools = require("./tools");
 
+var _tracekit = require("../tracekit");
+
 var ErrorSource = {
   AGENT: 'agent',
   CONSOLE: 'console',
@@ -20,11 +23,12 @@ var ErrorSource = {
 };
 exports.ErrorSource = ErrorSource;
 
-function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
+function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {
   if (!stackTrace || stackTrace.message === undefined && !(errorObject instanceof Error)) {
     return {
       message: nonErrorPrefix + '' + JSON.stringify(errorObject),
       stack: 'No stack, consider using an instance of Error',
+      handlingStack: handlingStack,
       type: stackTrace && stackTrace.name
     };
   }
@@ -32,9 +36,43 @@ function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
   return {
     message: stackTrace.message || 'Empty message',
     stack: toStackTraceString(stackTrace),
+    handlingStack: handlingStack,
     type: stackTrace.name
   };
 }
+/**
+ Creates a stacktrace without SDK internal frames.
+ 
+ Constraints:
+ - Has to be called at the utmost position of the call stack.
+ - No internal monitoring should encapsulate the function, that is why we need to use callMonitored inside of it.
+ */
+
+
+function createHandlingStack() {
+  /**
+   * Skip the two internal frames:
+   * - SDK API (console.error, ...)
+   * - this function
+   * in order to keep only the user calls
+   */
+  var internalFramesToSkip = 2;
+  var error = new Error();
+  var formattedStack; // IE needs to throw the error to fill in the stack trace
+
+  if (!error.stack) {
+    try {
+      throw error;
+    } catch (e) {
+      (0, _tools.noop)();
+    }
+  }
+
+  var stackTrace = (0, _tracekit.computeStackTrace)(error);
+  stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);
+  formattedStack = toStackTraceString(stackTrace);
+  return formattedStack;
+}
 
 function toStackTraceString(stack) {
   var result = stack.name || 'Error' + ': ' + stack.message;

package/cjs/helper/tools.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.UUID = UUID;
 exports.replaceNumberCharByPath = replaceNumberCharByPath;
+exports.getType = getType;
+exports.mergeInto = mergeInto;
+exports.deepClone = deepClone;
 exports.getStatusGroup = getStatusGroup;
 exports.jsonStringify = jsonStringify;
 exports.noop = noop;
@@ -803,8 +806,8 @@ var urlParse = function urlParse(para) {
 
   URLParser.prototype.getUrl = function () {
     var url = '';
-    url += this._values.Origin;
-    url += this._values.Port ? ':' + this._values.Port : '';
+    url += this._values.Origin; // url += this._values.Port ? ':' + this._values.Port : ''
+
     url += this._values.Path;
     url += this._values.QueryString ? '?' + this._values.QueryString : '';
     return url;
@@ -825,8 +828,11 @@ var urlParse = function urlParse(para) {
       }
     }
 
+    this._values['Path'] = this._values['Path'] || '/';
     this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '');
-    this._values['Origin'] = this._values['Protocol'] + '://' + this._values['Hostname'];
+    this._values['Origin'] = this._values['Protocol'] + '://' + this._values['Hostname'] + (this._values.Port ? ':' + this._values.Port : ''); // this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '')
+    // this._values['Origin'] =
+    //   this._values['Protocol'] + '://' + this._values['Hostname']
   };
 
   return new URLParser(para);
@@ -1309,6 +1315,113 @@ var getURLSearchParams = function getURLSearchParams(queryString) {
 
 exports.getURLSearchParams = getURLSearchParams;
 
+function createCircularReferenceChecker() {
+  if (typeof WeakSet !== 'undefined') {
+    var set = new WeakSet();
+    return {
+      hasAlreadyBeenSeen: function hasAlreadyBeenSeen(value) {
+        var has = set.has(value);
+
+        if (!has) {
+          set.add(value);
+        }
+
+        return has;
+      }
+    };
+  }
+
+  var array = [];
+  return {
+    hasAlreadyBeenSeen: function hasAlreadyBeenSeen(value) {
+      var has = array.indexOf(value) >= 0;
+
+      if (!has) {
+        array.push(value);
+      }
+
+      return has;
+    }
+  };
+}
+/**
+ * Similar to `typeof`, but distinguish plain objects from `null` and arrays
+ */
+
+
+function getType(value) {
+  if (value === null) {
+    return 'null';
+  }
+
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+
+  return _typeof(value);
+}
+/**
+ * Iterate over source and affect its sub values into destination, recursively.
+ * If the source and destination can't be merged, return source.
+ */
+
+
+function mergeInto(destination, source, circularReferenceChecker) {
+  // ignore the source if it is undefined
+  if (typeof circularReferenceChecker === 'undefined') {
+    circularReferenceChecker = createCircularReferenceChecker();
+  }
+
+  if (source === undefined) {
+    return destination;
+  }
+
+  if (_typeof(source) !== 'object' || source === null) {
+    // primitive values - just return source
+    return source;
+  } else if (source instanceof Date) {
+    return new Date(source.getTime());
+  } else if (source instanceof RegExp) {
+    var flags = source.flags || // old browsers compatibility
+    [source.global ? 'g' : '', source.ignoreCase ? 'i' : '', source.multiline ? 'm' : '', source.sticky ? 'y' : '', source.unicode ? 'u' : ''].join('');
+    return new RegExp(source.source, flags);
+  }
+
+  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
+    // remove circular references
+    return undefined;
+  } else if (Array.isArray(source)) {
+    var merged = Array.isArray(destination) ? destination : [];
+
+    for (var i = 0; i < source.length; ++i) {
+      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker);
+    }
+
+    return merged;
+  }
+
+  var merged = getType(destination) === 'object' ? destination : {};
+
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);
+    }
+  }
+
+  return merged;
+}
+/**
+ * A simplistic implementation of a deep clone algorithm.
+ * Caveats:
+ * - It doesn't maintain prototype chains - don't use with instances of custom classes.
+ * - It doesn't handle Map and Set
+ */
+
+
+function deepClone(value) {
+  return mergeInto(undefined, value);
+}
+
 var _URL = function _URL(url) {
   var result = {};
   var basicProps = ['hash', 'host', 'hostname', 'href', 'origin', 'password', 'pathname', 'port', 'protocol', 'search', 'username'];

package/esm/configuration.js

@@ -76,6 +76,7 @@ export function commonInit(userConfiguration, buildEnv) {
     applicationId: userConfiguration.applicationId,
     env: userConfiguration.env || '',
     version: userConfiguration.version || '',
+    service: userConfiguration.service || 'browser',
     sdkVersion: buildEnv.sdkVersion,
     sdkName: buildEnv.sdkName,
     datakitUrl: getDatakitUrl(userConfiguration.datakitUrl || userConfiguration.datakitOrigin),
@@ -135,5 +136,21 @@ function mustUseSecureCookie(userConfiguration) {
 }
 
 export function isIntakeRequest(url, configuration) {
-  return haveSameOrigin(url, configuration.datakitUrl);
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl];
+
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint);
+  }
+
+  var isIntake = false;
+
+  for (var _url of notTakeRequest) {
+    if (url.indexOf(_url) === 0) {
+      isIntake = true;
+      break;
+    }
+  }
+
+  return isIntake;
 }

package/esm/dataMap.js

@@ -93,6 +93,7 @@ export var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
+      error_handling: 'error.handling',
       resource_url: 'error.resource.url',
       resource_url_host: 'error.resource.url_host',
       resource_url_path: 'error.resource.url_path',

package/esm/errorCollection.js

@@ -1,9 +1,9 @@
 import { toArray, jsonStringify, find, clocksNow, map, extend } from './helper/tools';
-import { ErrorSource, formatUnknownError, toStackTraceString, formatErrorMessage } from './helper/errorTools';
+import { ErrorSource, formatUnknownError, toStackTraceString, formatErrorMessage, createHandlingStack } from './helper/errorTools';
 import { computeStackTrace, subscribe, unsubscribe } from './tracekit';
 import { Observable } from './helper/observable';
 import { isIntakeRequest } from './configuration';
-import { RequestType } from './helper/enums';
+import { RequestType, ErrorHandling } from './helper/enums';
 import { resetXhrProxy, startXhrProxy } from './xhrProxy';
 import { resetFetchProxy, startFetchProxy } from './fetchProxy';
 var errorObservable;
@@ -23,14 +23,16 @@ export function startConsoleTracking(errorObservable) {
 
   console.error = function () {
     originalConsoleError.apply(console, arguments);
-    errorObservable.notify(extend({}, buildErrorFromParams(toArray(arguments)), {
+    var handlingStack = createHandlingStack();
+    errorObservable.notify(extend({}, buildErrorFromParams(toArray(arguments), handlingStack), {
       source: ErrorSource.CONSOLE,
-      startClocks: clocksNow()
+      startClocks: clocksNow(),
+      handling: ErrorHandling.HANDLED
     }));
   };
 }
 
-function buildErrorFromParams(params) {
+function buildErrorFromParams(params, handlingStack) {
   var firstErrorParam = find(params, function (param) {
     return param instanceof Error;
   });
@@ -40,7 +42,8 @@ function buildErrorFromParams(params) {
   }).join(' ');
   return {
     message: message,
-    stack: firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined
+    stack: firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined,
+    handlingStack: handlingStack
   };
 }
 
@@ -69,7 +72,8 @@ export function startRuntimeErrorTracking(errorObservable) {
       stack: error.stack,
       type: error.type,
       source: ErrorSource.SOURCE,
-      startClocks: clocksNow()
+      startClocks: clocksNow(),
+      handling: ErrorHandling.UNHANDLED
     });
   };
 

package/esm/helper/errorTools.js

@@ -1,4 +1,5 @@
-import { each } from './tools';
+import { each, noop } from './tools';
+import { computeStackTrace } from '../tracekit';
 export var ErrorSource = {
   AGENT: 'agent',
   CONSOLE: 'console',
@@ -7,11 +8,12 @@ export var ErrorSource = {
   LOGGER: 'logger',
   CUSTOM: 'custom'
 };
-export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
+export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {
   if (!stackTrace || stackTrace.message === undefined && !(errorObject instanceof Error)) {
     return {
       message: nonErrorPrefix + '' + JSON.stringify(errorObject),
       stack: 'No stack, consider using an instance of Error',
+      handlingStack: handlingStack,
       type: stackTrace && stackTrace.name
     };
   }
@@ -19,9 +21,42 @@ export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
   return {
     message: stackTrace.message || 'Empty message',
     stack: toStackTraceString(stackTrace),
+    handlingStack: handlingStack,
     type: stackTrace.name
   };
 }
+/**
+ Creates a stacktrace without SDK internal frames.
+ 
+ Constraints:
+ - Has to be called at the utmost position of the call stack.
+ - No internal monitoring should encapsulate the function, that is why we need to use callMonitored inside of it.
+ */
+
+export function createHandlingStack() {
+  /**
+   * Skip the two internal frames:
+   * - SDK API (console.error, ...)
+   * - this function
+   * in order to keep only the user calls
+   */
+  var internalFramesToSkip = 2;
+  var error = new Error();
+  var formattedStack; // IE needs to throw the error to fill in the stack trace
+
+  if (!error.stack) {
+    try {
+      throw error;
+    } catch (e) {
+      noop();
+    }
+  }
+
+  var stackTrace = computeStackTrace(error);
+  stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);
+  formattedStack = toStackTraceString(stackTrace);
+  return formattedStack;
+}
 export function toStackTraceString(stack) {
   var result = stack.name || 'Error' + ': ' + stack.message;
   each(stack.stack, function (frame) {

package/esm/helper/tools.js

@@ -625,8 +625,8 @@ export var urlParse = function urlParse(para) {
 
   URLParser.prototype.getUrl = function () {
     var url = '';
-    url += this._values.Origin;
-    url += this._values.Port ? ':' + this._values.Port : '';
+    url += this._values.Origin; // url += this._values.Port ? ':' + this._values.Port : ''
+
     url += this._values.Path;
     url += this._values.QueryString ? '?' + this._values.QueryString : '';
     return url;
@@ -647,8 +647,11 @@ export var urlParse = function urlParse(para) {
       }
     }
 
+    this._values['Path'] = this._values['Path'] || '/';
     this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '');
-    this._values['Origin'] = this._values['Protocol'] + '://' + this._values['Hostname'];
+    this._values['Origin'] = this._values['Protocol'] + '://' + this._values['Hostname'] + (this._values.Port ? ':' + this._values.Port : ''); // this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '')
+    // this._values['Origin'] =
+    //   this._values['Protocol'] + '://' + this._values['Hostname']
   };
 
   return new URLParser(para);
@@ -1095,6 +1098,113 @@ export var getURLSearchParams = function getURLSearchParams(queryString) {
 
   return args;
 };
+
+function createCircularReferenceChecker() {
+  if (typeof WeakSet !== 'undefined') {
+    var set = new WeakSet();
+    return {
+      hasAlreadyBeenSeen(value) {
+        var has = set.has(value);
+
+        if (!has) {
+          set.add(value);
+        }
+
+        return has;
+      }
+
+    };
+  }
+
+  var array = [];
+  return {
+    hasAlreadyBeenSeen(value) {
+      var has = array.indexOf(value) >= 0;
+
+      if (!has) {
+        array.push(value);
+      }
+
+      return has;
+    }
+
+  };
+}
+/**
+ * Similar to `typeof`, but distinguish plain objects from `null` and arrays
+ */
+
+
+export function getType(value) {
+  if (value === null) {
+    return 'null';
+  }
+
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+
+  return typeof value;
+}
+/**
+ * Iterate over source and affect its sub values into destination, recursively.
+ * If the source and destination can't be merged, return source.
+ */
+
+export function mergeInto(destination, source, circularReferenceChecker) {
+  // ignore the source if it is undefined
+  if (typeof circularReferenceChecker === 'undefined') {
+    circularReferenceChecker = createCircularReferenceChecker();
+  }
+
+  if (source === undefined) {
+    return destination;
+  }
+
+  if (typeof source !== 'object' || source === null) {
+    // primitive values - just return source
+    return source;
+  } else if (source instanceof Date) {
+    return new Date(source.getTime());
+  } else if (source instanceof RegExp) {
+    var flags = source.flags || // old browsers compatibility
+    [source.global ? 'g' : '', source.ignoreCase ? 'i' : '', source.multiline ? 'm' : '', source.sticky ? 'y' : '', source.unicode ? 'u' : ''].join('');
+    return new RegExp(source.source, flags);
+  }
+
+  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
+    // remove circular references
+    return undefined;
+  } else if (Array.isArray(source)) {
+    var merged = Array.isArray(destination) ? destination : [];
+
+    for (var i = 0; i < source.length; ++i) {
+      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker);
+    }
+
+    return merged;
+  }
+
+  var merged = getType(destination) === 'object' ? destination : {};
+
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);
+    }
+  }
+
+  return merged;
+}
+/**
+ * A simplistic implementation of a deep clone algorithm.
+ * Caveats:
+ * - It doesn't maintain prototype chains - don't use with instances of custom classes.
+ * - It doesn't handle Map and Set
+ */
+
+export function deepClone(value) {
+  return mergeInto(undefined, value);
+}
 export var _URL = function _URL(url) {
   var result = {};
   var basicProps = ['hash', 'host', 'hostname', 'href', 'origin', 'password', 'pathname', 'port', 'protocol', 'search', 'username'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcare/browser-core",
-  "version": "1.0.16",
+  "version": "1.0.19",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "scripts": {
@@ -20,5 +20,5 @@
   "author": "dataflux",
   "license": "MIT",
   "description": "DataFlux RUM Web 端数据指标监控",
-  "gitHead": "82f05e083d4c4a86615dd759de38dda0674eb84f"
+  "gitHead": "642b7a18f128ce5297dcb9b73df3136418c8c53e"
 }

package/src/configuration.js

@@ -77,6 +77,7 @@ export function commonInit(userConfiguration, buildEnv) {
     applicationId: userConfiguration.applicationId,
     env: userConfiguration.env || '',
     version: userConfiguration.version || '',
+    service: userConfiguration.service || 'browser',
     sdkVersion: buildEnv.sdkVersion,
     sdkName: buildEnv.sdkName,
     datakitUrl: getDatakitUrl(
@@ -131,5 +132,17 @@ function mustUseSecureCookie(userConfiguration) {
 }
 
 export function isIntakeRequest(url, configuration) {
-  return haveSameOrigin(url, configuration.datakitUrl)
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl]
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint)
+  }
+  var isIntake = false
+  for(var _url of notTakeRequest) {
+    if (url.indexOf(_url) === 0) {
+      isIntake = true
+      break;
+    }
+  }
+  return isIntake
 }

package/src/dataMap.js

@@ -93,6 +93,7 @@ export var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
+      error_handling: 'error.handling',
       resource_url: 'error.resource.url',
       resource_url_host: 'error.resource.url_host',
       resource_url_path: 'error.resource.url_path',

package/src/errorCollection.js

@@ -10,12 +10,13 @@ import {
   ErrorSource,
   formatUnknownError,
   toStackTraceString,
-  formatErrorMessage
+  formatErrorMessage,
+  createHandlingStack
 } from './helper/errorTools'
 import { computeStackTrace, subscribe, unsubscribe } from './tracekit'
 import { Observable } from './helper/observable'
 import { isIntakeRequest } from './configuration'
-import { RequestType } from './helper/enums'
+import { RequestType, ErrorHandling } from './helper/enums'
 import { resetXhrProxy, startXhrProxy } from './xhrProxy'
 import { resetFetchProxy, startFetchProxy } from './fetchProxy'
 
@@ -37,16 +38,18 @@ export function startConsoleTracking(errorObservable) {
   originalConsoleError = console.error
   console.error = function () {
     originalConsoleError.apply(console, arguments)
+    const handlingStack = createHandlingStack()
     errorObservable.notify(
-      extend({}, buildErrorFromParams(toArray(arguments)), {
+      extend({}, buildErrorFromParams(toArray(arguments), handlingStack), {
         source: ErrorSource.CONSOLE,
-        startClocks: clocksNow()
+        startClocks: clocksNow(),
+        handling: ErrorHandling.HANDLED
       })
     )
   }
 }
 
-function buildErrorFromParams(params) {
+function buildErrorFromParams(params, handlingStack) {
   var firstErrorParam = find(params, function (param) {
     return param instanceof Error
   })
@@ -58,7 +61,8 @@ function buildErrorFromParams(params) {
     message: message,
     stack: firstErrorParam
       ? toStackTraceString(computeStackTrace(firstErrorParam))
-      : undefined
+      : undefined,
+    handlingStack: handlingStack
   }
 }
 
@@ -86,7 +90,8 @@ export function startRuntimeErrorTracking(errorObservable) {
       stack: error.stack,
       type: error.type,
       source: ErrorSource.SOURCE,
-      startClocks: clocksNow()
+      startClocks: clocksNow(),
+      handling: ErrorHandling.UNHANDLED
     })
   }
 

package/src/helper/errorTools.js

@@ -1,4 +1,6 @@
-import { each } from './tools'
+import { each , noop} from './tools'
+import { computeStackTrace} from '../tracekit'
+
 export var ErrorSource = {
   AGENT: 'agent',
   CONSOLE: 'console',
@@ -7,7 +9,8 @@ export var ErrorSource = {
   LOGGER: 'logger',
   CUSTOM: 'custom'
 }
-export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
+
+export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix,handlingStack) {
   if (
     !stackTrace ||
     (stackTrace.message === undefined && !(errorObject instanceof Error))
@@ -15,16 +18,50 @@ export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix) {
     return {
       message: nonErrorPrefix + '' + JSON.stringify(errorObject),
       stack: 'No stack, consider using an instance of Error',
+      handlingStack:handlingStack,
       type: stackTrace && stackTrace.name
     }
   }
   return {
     message: stackTrace.message || 'Empty message',
     stack: toStackTraceString(stackTrace),
+    handlingStack:handlingStack,
     type: stackTrace.name
   }
 }
+/**
+ Creates a stacktrace without SDK internal frames.
+ 
+ Constraints:
+ - Has to be called at the utmost position of the call stack.
+ - No internal monitoring should encapsulate the function, that is why we need to use callMonitored inside of it.
+ */
+ export function createHandlingStack() {
+  /**
+   * Skip the two internal frames:
+   * - SDK API (console.error, ...)
+   * - this function
+   * in order to keep only the user calls
+   */
+  const internalFramesToSkip = 2
+  const error = new Error()
+  let formattedStack
 
+  // IE needs to throw the error to fill in the stack trace
+  if (!error.stack) {
+    try {
+      throw error
+    } catch (e) {
+      noop()
+    }
+  }
+
+  const stackTrace = computeStackTrace(error)
+  stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
+  formattedStack = toStackTraceString(stackTrace)
+
+  return formattedStack
+}
 export function toStackTraceString(stack) {
   var result = stack.name || 'Error' + ': ' + stack.message
   each(stack.stack, function (frame) {

package/src/helper/tools.js

@@ -613,7 +613,7 @@ export var urlParse = function (para) {
   URLParser.prototype.getUrl = function () {
     var url = ''
     url += this._values.Origin
-    url += this._values.Port ? ':' + this._values.Port : ''
+    // url += this._values.Port ? ':' + this._values.Port : ''
     url += this._values.Path
     url += this._values.QueryString ? '?' + this._values.QueryString : ''
     return url
@@ -629,9 +629,13 @@ export var urlParse = function (para) {
         this._values[c] = b[this._fields[c]]
       }
     }
-    this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '')
-    this._values['Origin'] =
-      this._values['Protocol'] + '://' + this._values['Hostname']
+    this._values['Path'] = this._values['Path'] || '/'
+		this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '')
+		this._values['Origin'] =
+			this._values['Protocol'] + '://' + this._values['Hostname'] + (this._values.Port ? ':' + this._values.Port : '')
+    // this._values['Hostname'] = this._values['Host'].replace(/:\d+$/, '')
+    // this._values['Origin'] =
+    //   this._values['Protocol'] + '://' + this._values['Hostname']
   }
   return new URLParser(para)
 }
@@ -1060,7 +1064,107 @@ export var getURLSearchParams = function (queryString) {
   }
   return args
 }
+function createCircularReferenceChecker() {
+  if (typeof WeakSet !== 'undefined') {
+    var set = new WeakSet()
+    return {
+      hasAlreadyBeenSeen(value) {
+        var has = set.has(value)
+        if (!has) {
+          set.add(value)
+        }
+        return has
+      },
+    }
+  }
+  var array = []
+  return {
+    hasAlreadyBeenSeen(value) {
+      var has = array.indexOf(value) >= 0
+      if (!has) {
+        array.push(value)
+      }
+      return has
+    },
+  }
+}
+/**
+ * Similar to `typeof`, but distinguish plain objects from `null` and arrays
+ */
+ export function getType(value) {
+  if (value === null) {
+    return 'null'
+  }
+  if (Array.isArray(value)) {
+    return 'array'
+  }
+  return typeof value
+}
+/**
+ * Iterate over source and affect its sub values into destination, recursively.
+ * If the source and destination can't be merged, return source.
+ */
+ export function mergeInto(
+  destination,
+  source,
+  circularReferenceChecker
+) {
+  // ignore the source if it is undefined
+  if (typeof circularReferenceChecker === 'undefined') {
+    circularReferenceChecker = createCircularReferenceChecker()
+  }
+  if (source === undefined) {
+    return destination
+  }
+
+  if (typeof source !== 'object' || source === null) {
+    // primitive values - just return source
+    return source
+  } else if (source instanceof Date) {
+    return new Date(source.getTime())
+  } else if (source instanceof RegExp) {
+    var flags =
+      source.flags ||
+      // old browsers compatibility
+      [
+        source.global ? 'g' : '',
+        source.ignoreCase ? 'i' : '',
+        source.multiline ? 'm' : '',
+        source.sticky ? 'y' : '',
+        source.unicode ? 'u' : '',
+      ].join('')
+    return new RegExp(source.source, flags)
+  }
+
+  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
+    // remove circular references
+    return undefined
+  } else if (Array.isArray(source)) {
+    var merged= Array.isArray(destination) ? destination : []
+    for (var i = 0; i < source.length; ++i) {
+      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker)
+    }
+    return merged
+  }
+
+  var merged = getType(destination) === 'object' ? destination : {}
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker)
+    }
+  }
+  return merged
+}
 
+/**
+ * A simplistic implementation of a deep clone algorithm.
+ * Caveats:
+ * - It doesn't maintain prototype chains - don't use with instances of custom classes.
+ * - It doesn't handle Map and Set
+ */
+export function deepClone(value){
+  return mergeInto(undefined, value)
+}
 export var _URL = function (url) {
   var result = {}
   var basicProps = [