@cloudcare/browser-core 1.1.2 → 1.2.0

package/src/helper/tools.js

@@ -178,6 +178,63 @@ export var map = function (arr, fn, self) {
   }
   return ret
 }
+export var some = function(arr, fn, self) {
+  if (arr.some) {
+    return arr.some(fn)
+  }
+  var flag = false
+  for(var i = 0; i < arr.length; i++) {
+    if (!hasOwnProperty.call(arr, i)) {
+      continue
+    }
+    var val = arr[i]
+    if (fn.call(self, val, i, arr)) {
+      flag = true
+      break;
+    }
+  }
+  return flag
+}
+export var every = function(arr, fn, self) {
+  if (arr.every) {
+    return arr.every(fn)
+  }
+  var flag = true
+  for(var i = 0; i < arr.length; i++) {
+    if (!hasOwnProperty.call(arr, i)) {
+      continue
+    }
+    var val = arr[i]
+    if (!fn.call(self, val, i, arr)) {
+      flag = false
+      break;
+    }
+  }
+  return flag
+}
+export var matchList = function(list, value) {
+  return some(list, function(item) {return item === value || (item instanceof RegExp && item.test(value))})
+}
+// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js
+export var cssEscape = function(str) {
+  if (window.CSS && window.CSS.escape) {
+    return window.CSS.escape(str)
+  }
+
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, function (ch, asCodePoint) {
+    if (asCodePoint) {
+      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+      if (ch === '\0') {
+        return '\uFFFD'
+      }
+      // Control characters and (dependent upon position) numbers get escaped as code points
+      return ch.slice(0, -1) + '\\' + ch.charCodeAt(ch.length - 1).toString(16) + ' '
+    }
+    // Other potentially-special ASCII characters get backslash-escaped
+    return '\\' + ch
+  })
+}
 export var inherit = function (subclass, superclass) {
   var F = function () {}
   F.prototype = superclass.prototype
@@ -654,6 +711,16 @@ export var urlParse = function (para) {
   }
   return new URLParser(para)
 }
+export function elementMatches(element, selector) {
+  if (element.matches) {
+    return element.matches(selector)
+  }
+  // IE11 support
+  if (element.msMatchesSelector) {
+    return element.msMatchesSelector(selector)
+  }
+  return false
+}
 export var addEvent = function () {
   function fixEvent(event) {
     if (event) {
@@ -1463,7 +1530,10 @@ export function noop() {}
 export var ONE_SECOND = 1000
 export var ONE_MINUTE = 60 * ONE_SECOND
 export var ONE_HOUR = 60 * ONE_MINUTE
-export var ONE_KILO_BYTE = 1024
+export var ONE_DAY = 24 * ONE_HOUR
+export var ONE_YEAR = 365 * ONE_DAY
+export var ONE_KIBI_BYTE = 1024
+export var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE
 /**
  * Return true if the draw is successful
  * @param threshold between 0 and 100
@@ -1504,7 +1574,7 @@ export function preferredNow() {
   return relativeNow()
 }
 export function getTimestamp(relativeTime) {
-  return Math.floor(getNavigationStart() + relativeTime)
+  return Math.round(getNavigationStart() + relativeTime)
 }
 export function relativeNow() {
   return performance.now()
@@ -1514,8 +1584,21 @@ export function clocksNow() {
   return { relative: relativeNow(), timeStamp: timeStampNow() }
 }
 export function timeStampNow() {
+  return dateNow()
+}
+
+export function looksLikeRelativeTime(time) {
+  return time < ONE_YEAR
+}
+export function dateNow() {
+  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
+  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
+  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
+  // case ourselves.
+  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
   return new Date().getTime()
 }
+
 export function elapsed(start, end) {
   return end - start
 }
@@ -1530,7 +1613,20 @@ export function preferredTimeStamp(clocks) {
   return getTimestamp(clocks.relative)
 }
 export function relativeToClocks(relative) {
-  return { relative: relative, timeStamp: getTimestamp(relative) }
+  return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) }
+}
+export function currentDrift() {
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  return Math.round(dateNow() - (getNavigationStart() + performance.now()))
+}
+
+function getCorrectedTimeStamp(relativeTime) {
+  var correctedOrigin = dateNow() - performance.now()
+  // apply correction only for positive drift
+  if (correctedOrigin > getNavigationStart()) {
+    return Math.round(correctedOrigin + relativeTime)
+  }
+  return getTimestamp(relativeTime)
 }
 /**
  * Navigation start slightly change on some rare cases
@@ -1643,7 +1739,25 @@ export function createContextManager() {
       } else {
         console.error('content 需要传递对象类型数据')
       }
-      
+    },
+    getContext: function() {
+      return deepClone(context)
+    },
+
+    setContext: function(newContext)  {
+      context = deepClone(newContext)
+    },
+
+    setContextProperty: function(key, property){
+      context[key] = deepClone(property)
+    },
+
+    removeContextProperty: function(key){
+      delete context[key]
+    },
+
+    clearContext: function(){
+      context = {}
     }
   }
 }
@@ -1656,7 +1770,32 @@ export function find(array, predicate) {
   }
   return undefined
 }
-
+export function arrayFrom(arrayLike) {
+  if (Array.from) {
+    return Array.from(arrayLike)
+  }
+  var array = []
+  if (arrayLike instanceof Set) {
+    arrayLike.forEach(function(item) { array.push(item) })
+  } else {
+    for (var i = 0; i < arrayLike.length; i++) {
+      array.push(arrayLike[i])
+    }
+  }
+  return array
+}
+export function findLast(
+  array,
+  predicate
+) {
+  for (var i = array.length - 1; i >= 0; i -= 1) {
+    var item = array[i]
+    if (predicate(item, i, array)) {
+      return item
+    }
+  }
+  return undefined
+}
 export function isPercentage(value) {
   return isNumber(value) && value >= 0 && value <= 100
 }
@@ -1665,6 +1804,14 @@ export function getLocationOrigin() {
   return getLinkElementOrigin(window.location)
 }
 
+export function isIE() {
+  return Boolean(document.documentMode)
+}
+
+export function isChromium() {
+  return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent)
+}
+
 /**
  * IE fallback
  * https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin
@@ -1738,3 +1885,10 @@ export function escapeRowField(value) {
     return value
   }
 }
+export function isNullUndefinedDefaultValue(data,defaultValue) {
+  if (data !== null && data !== void 0) {
+    return data
+  } else {
+    return defaultValue
+  }
+}

package/src/index.js

@@ -1,22 +1,33 @@
 export * from './helper/boundedBuffer'
+export * from './helper/contextHistory'
 export * from './helper/deviceInfo'
 export * from './helper/enums'
-export * from './helper/errorFilter'
+export * from './helper/instrumentMethod'
 export * from './helper/errorTools'
+export * from './error/trackRuntimeError'
+export * from './console/consoleObservable'
+export * from './report/reportObservable'
+export * from './helper/display'
 export * from './helper/eventEmitter'
 export * from './helper/lifeCycle'
 export * from './helper/limitModification'
+export * from './helper/createEventRateLimiter'
 export * from './helper/observable'
 export * from './helper/tools'
 export * from './helper/urlPolyfill'
 export * from './helper/mobileUtil'
 export * from './tracekit'
-export * from './configuration'
-export * from './cookie'
+export * from './configuration/configuration'
+export * from './configuration/transportConfiguration'
+export * from './browser/cookie'
+export * from './browser/fetchObservable'
+export * from './browser/xhrObservable'
 export * from './dataMap'
-export * from './errorCollection'
-export * from './fetchProxy'
 export * from './init'
-export * from './sessionManagement'
+export * from './session/sessionManagement'
+export * from './session/sessionConstants'
+export * from './session/sessionCookieStore'
+export * from './session/sessionStore'
 export * from './transport'
-export * from './xhrProxy'
+export * from './synthetics/syntheticsWorkerValues'
+

package/src/init.js

@@ -1,5 +1,4 @@
 import { extend, each } from './helper/tools'
-import { areCookiesAuthorized } from './cookie'
 export function makeGlobal(stub) {
   var global = extend({}, stub, {
     onReady: function (callback) {
@@ -63,22 +62,22 @@ export function getGlobalObject() {
   }
   return globalObject
 }
-export function checkCookiesAuthorized(options) {
-  if (!areCookiesAuthorized(options)) {
-    console.warn('Cookies are not authorized, we will not send any data.')
-    return false
-  }
-  return true
-}
+// export function checkCookiesAuthorized(options) {
+//   if (!areCookiesAuthorized(options)) {
+//     console.warn('Cookies are not authorized, we will not send any data.')
+//     return false
+//   }
+//   return true
+// }
 
-export function checkIsNotLocalFile() {
-  if (isLocalFile()) {
-    console.error('Execution is not allowed in the current context.')
-    return false
-  }
-  return true
-}
+// export function checkIsNotLocalFile() {
+//   if (isLocalFile()) {
+//     console.error('Execution is not allowed in the current context.')
+//     return false
+//   }
+//   return true
+// }
 
-function isLocalFile() {
-  return window.location.protocol === 'file:'
-}
+// function isLocalFile() {
+//   return window.location.protocol === 'file:'
+// }

package/src/report/reportObservable.js

@@ -0,0 +1,113 @@
+import { toStackTraceString } from '../helper/errorTools'
+import { mergeObservables, Observable } from '../helper/observable'
+import { includes, addEventListener, safeTruncate, filter, each } from '../helper/tools'
+import { DOM_EVENT } from '../helper/enums'
+export var RawReportType = {
+  intervention: 'intervention',
+  deprecation: 'deprecation',
+  cspViolation: 'csp_violation',
+}
+export function initReportObservable(apis) {
+  var observables = []
+
+  if (includes(apis, RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable())
+  }
+
+  var reportTypes = filter(apis, function(api) { return api !== RawReportType.cspViolation })
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes))
+  }
+  return mergeObservables.apply(this, observables)
+}
+
+function createReportObservable(reportTypes) {
+  var observable = new Observable(function() {
+    if (!window.ReportingObserver) {
+      return
+    }
+
+    var handleReports = function(reports) {
+      each(reports, function(report) {
+        observable.notify(buildRawReportFromReport(report))
+      })
+    }
+
+    var observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true,
+    })
+
+    observer.observe()
+    return function() {
+      observer.disconnect()
+    }
+  })
+
+  return observable
+}
+
+function createCspViolationReportObservable() {
+  var observable = new Observable(function() {
+    var handleCspViolation = function(event) {
+      observable.notify(buildRawReportFromCspViolation(event))
+    }
+
+    var _addEventListener = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, handleCspViolation)
+
+    return _addEventListener.stop
+  })
+  return observable
+}
+
+function buildRawReportFromReport(report) {
+  var body = report.body
+  var type = report.type
+  return {
+    type: type,
+    subtype: body.id,
+    message: type + ': ' + body.message,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
+  }
+}
+
+function buildRawReportFromCspViolation(event) {
+  var type = RawReportType.cspViolation
+  var message = '\''+ event.blockedURI + '\' blocked by \'' + event.effectiveDirective + '\' directive'
+  return {
+    type: RawReportType.cspViolation,
+    subtype: event.effectiveDirective,
+    message: type + ': ' + message,
+    stack: buildStack(
+      event.effectiveDirective,
+      message + ' of the policy "'+ safeTruncate(event.originalPolicy, 100, '...') + '"',
+      event.sourceFile,
+      event.lineNumber,
+      event.columnNumber
+    ),
+  }
+}
+
+function buildStack(
+  name,
+  message,
+  sourceFile,
+  lineNumber,
+  columnNumber
+){
+  return (
+    sourceFile &&
+    toStackTraceString({
+      name: name,
+      message: message,
+      stack: [
+        {
+          func: '?',
+          url: sourceFile,
+          line: lineNumber,
+          column: columnNumber,
+        },
+      ],
+    })
+  )
+}

package/src/session/sessionConstants.js

@@ -0,0 +1,3 @@
+import { ONE_HOUR, ONE_MINUTE } from '../helper/tools'
+export var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
+export var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE

package/src/session/sessionCookieStore.js

@@ -0,0 +1,159 @@
+import { getCookie, setCookie } from '../browser/cookie'
+import { isChromium, dateNow, isEmptyObject, UUID, objectEntries,map, each, } from '../helper/tools'
+import { SESSION_EXPIRATION_DELAY } from './sessionConstants'
+
+var SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/
+var SESSION_ENTRY_SEPARATOR = '&'
+
+export var SESSION_COOKIE_NAME = '_dataflux_s'
+
+// arbitrary values
+export var LOCK_RETRY_DELAY = 10
+export var MAX_NUMBER_OF_LOCK_RETRIES = 100
+
+
+var bufferedOperations= []
+var ongoingOperations
+
+export function withCookieLockAccess(operations, numberOfRetries) {
+  if (typeof numberOfRetries === 'undefined') {
+    numberOfRetries = 0
+  }
+  if (!ongoingOperations) {
+    ongoingOperations = operations
+  }
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations)
+    return
+  }
+  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {
+    next()
+    return
+  }
+  var currentLock
+  var currentSession = retrieveSession()
+  if (isCookieLockEnabled()) {
+    // if someone has lock, retry later
+    if (currentSession.lock) {
+      retryLater(operations, numberOfRetries)
+      return
+    }
+    // acquire lock
+    currentLock = UUID()
+    currentSession.lock = currentLock
+    setSession(currentSession, operations.options)
+    // if lock is not acquired, retry later
+    currentSession = retrieveSession()
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries)
+      return
+    }
+  }
+  var processedSession = operations.process(currentSession)
+  if (isCookieLockEnabled()) {
+    // if lock corrupted after process, retry later
+    currentSession = retrieveSession()
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries)
+      return
+    }
+  }
+  if (processedSession) {
+    persistSession(processedSession, operations.options)
+  }
+  if (isCookieLockEnabled()) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentSession = retrieveSession()
+      if (currentSession.lock !== currentLock) {
+        retryLater(operations, numberOfRetries)
+        return
+      }
+      delete currentSession.lock
+      setSession(currentSession, operations.options)
+      processedSession = currentSession
+    }
+  }
+  // call after even if session is not persisted in order to perform operations on
+  // up-to-date cookie value, the value could have been modified by another tab
+  if (operations.after) {
+    operations.after(processedSession || currentSession)
+  }
+  next()
+}
+
+/**
+ * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.
+ * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.
+ */
+function isCookieLockEnabled() {
+  return isChromium()
+}
+
+function retryLater(operations, currentNumberOfRetries) {
+  setTimeout(
+    function() {
+      withCookieLockAccess(operations, currentNumberOfRetries + 1)
+    },
+    LOCK_RETRY_DELAY
+  )
+}
+
+function next() {
+  ongoingOperations = undefined
+  var nextOperations = bufferedOperations.shift()
+  if (nextOperations) {
+    withCookieLockAccess(nextOperations)
+  }
+}
+
+export function persistSession(session, options) {
+  if (isExpiredState(session)) {
+    clearSession(options)
+    return
+  }
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)
+  setSession(session, options)
+}
+
+function setSession(session, options) {
+  setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options)
+}
+
+export function toSessionString(session) {
+  return map(objectEntries(session), function(item) {
+    return item[0] + '=' + item[1]
+  }).join(SESSION_ENTRY_SEPARATOR)
+}
+
+export function retrieveSession() {
+  var sessionString = getCookie(SESSION_COOKIE_NAME)
+  var session = {}
+  if (isValidSessionString(sessionString)) {
+    each(sessionString.split(SESSION_ENTRY_SEPARATOR), function(entry) {
+      var matches = SESSION_ENTRY_REGEXP.exec(entry)
+      if (matches !== null) {
+        var key = matches[1]
+        var value = matches[2]
+        session[key] = value
+      }
+    })
+  }
+  return session
+}
+
+function isValidSessionString(sessionString) {
+  return (
+    sessionString !== undefined &&
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))
+  )
+}
+
+function isExpiredState(session) {
+  return isEmptyObject(session)
+}
+function clearSession(options) {
+  setCookie(SESSION_COOKIE_NAME, '', 0, options)
+}

package/src/session/sessionManagement.js

@@ -0,0 +1,89 @@
+import { relativeNow, clocksOrigin, ONE_MINUTE, each, addEventListeners, addEventListener } from '../helper/tools'
+import { ContextHistory } from '../helper/contextHistory'
+import { startSessionStore } from './sessionStore'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { DOM_EVENT } from '../helper/enums'
+
+export var VISIBILITY_CHECK_DELAY = ONE_MINUTE
+var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
+var stopCallbacks = []
+
+export var startSessionManager = function(
+  options,
+  productKey,
+  computeSessionState
+) {
+  var sessionStore = startSessionStore(options, productKey, computeSessionState)
+  stopCallbacks.push(function() {
+    return sessionStore.stop()
+  })
+
+  var sessionContextHistory = new ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY)
+  stopCallbacks.push(function() {
+    return sessionContextHistory.stop()
+  })
+
+  sessionStore.renewObservable.subscribe(function(){
+    sessionContextHistory.add(buildSessionContext(), relativeNow())
+  })
+  sessionStore.expireObservable.subscribe(function() {
+    sessionContextHistory.closeActive(relativeNow())
+  })
+
+  sessionStore.expandOrRenewSession()
+  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
+
+  trackActivity(function() { 
+    return sessionStore.expandOrRenewSession()
+  })
+  trackVisibility(function() {
+    return sessionStore.expandSession()
+  })
+
+  function buildSessionContext() {
+    return {
+      id: sessionStore.getSession().id,
+      trackingType: sessionStore.getSession()[productKey],
+    }
+  }
+
+  return {
+    findActiveSession: function(startTime) {
+      return sessionContextHistory.find(startTime)
+    },
+    renewObservable: sessionStore.renewObservable,
+    expireObservable: sessionStore.expireObservable,
+  }
+}
+
+export function stopSessionManager() {
+  each(stopCallbacks, function(e) {
+    return e()
+  })
+  stopCallbacks = []
+}
+
+function trackActivity(expandOrRenewSession) {
+  var _addEventListeners = addEventListeners(
+    window,
+    [DOM_EVENT.CLICK,DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],
+    expandOrRenewSession,
+    { capture: true, passive: true }
+  )
+  stopCallbacks.push(_addEventListeners.stop)
+}
+
+function trackVisibility(expandSession) {
+  var expandSessionWhenVisible = function() {
+    if (document.visibilityState === 'visible') {
+      expandSession()
+    }
+  }
+  var _addEventListener= addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)
+  stopCallbacks.push(_addEventListener.stop)
+
+  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)
+  stopCallbacks.push(function() {
+    clearInterval(visibilityCheckInterval)
+  })
+}