@cloudcare/browser-logs 1.1.24 → 1.2.1

package/src/domain/logsCollection/console/consoleCollection.js

@@ -0,0 +1,36 @@
+import { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable, LifeCycleEventType } from '@cloudcare/browser-core'
+import { StatusType } from '../../logger'
+
+
+var LogStatusForApi = {
+  [ConsoleApiName.log]: StatusType.info,
+  [ConsoleApiName.debug]: StatusType.debug,
+  [ConsoleApiName.info]: StatusType.info,
+  [ConsoleApiName.warn]: StatusType.warn,
+  [ConsoleApiName.error]: StatusType.error,
+}
+export function startConsoleCollection(configuration, lifeCycle) {
+  var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function(log) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message: log.message,
+        origin: ErrorSource.CONSOLE,
+        error:
+          log.api === ConsoleApiName.error
+            ? {
+                origin: ErrorSource.CONSOLE, // Todo: Remove in the next major release
+                stack: log.stack,
+              }
+            : undefined,
+        status: LogStatusForApi[log.api],
+      },
+    })
+  })
+
+  return {
+    stop: function(){
+      consoleSubscription.unsubscribe()
+    },
+  }
+}

package/src/domain/logsCollection/logger/loggerCollection.js

@@ -0,0 +1,48 @@
+import { includes, display, extend2Lev, ErrorSource, timeStampNow, LifeCycleEventType, isArray } from '@cloudcare/browser-core'
+import { StatusType, HandlerType } from '../../logger'
+
+export var STATUS_PRIORITIES = {
+  [StatusType.debug]: 0,
+  [StatusType.info]: 1,
+  [StatusType.warn]: 2,
+  [StatusType.error]: 3,
+}
+
+export function startLoggerCollection(lifeCycle) {
+  function handleLog(
+    logsMessage,
+    logger,
+    savedCommonContext,
+    savedDate
+  ) {
+    var messageContext = logsMessage.context
+
+    if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {
+      display(logsMessage.status, logsMessage.message, extend2Lev(logger.getContext(), messageContext))
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: savedDate || timeStampNow(),
+        message: logsMessage.message,
+        status: logsMessage.status,
+        origin: ErrorSource.LOGGER,
+      },
+      messageContext: messageContext,
+      savedCommonContext: savedCommonContext,
+      logger: logger,
+    })
+  }
+
+  return {
+    handleLog: handleLog,
+  }
+}
+
+export function isAuthorized(status, handlerType, logger) {
+  var loggerHandler = logger.getHandler()
+  var sanitizedHandlerType = isArray(loggerHandler) ? loggerHandler : [loggerHandler]
+  return (
+    STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && includes(sanitizedHandlerType, handlerType)
+  )
+}

package/src/domain/logsCollection/networkError/networkErrorCollection.js

@@ -0,0 +1,260 @@
+import {
+  ErrorSource,
+  initXhrObservable,
+  RequestType,
+  initFetchObservable,
+  computeStackTrace,
+  toStackTraceString,
+  noop,
+  each,
+  LifeCycleEventType,
+  getStatusGroup,
+  urlParse,
+  replaceNumberCharByPath
+} from '@cloudcare/browser-core'
+import { StatusType } from '../../logger'
+
+export function startNetworkErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop }
+  }
+
+  var xhrSubscription = initXhrObservable().subscribe(function(context){
+    if (context.state === 'complete') {
+      handleCompleteRequest(RequestType.XHR, context, configuration)
+    }
+  })
+  var fetchSubscription = initFetchObservable().subscribe(function(context) {
+    if (context.state === 'complete') {
+      handleCompleteRequest(RequestType.FETCH, context, configuration)
+    }
+  })
+
+  function handleCompleteRequest(type, request) {
+    if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request) || configuration.isServerError(request))) {
+      if ('xhr' in request) {
+        computeXhrResponseData(request.xhr, configuration, onResponseDataAvailable)
+      } else if (request.response) {
+        computeFetchResponseText(request.response, configuration, onResponseDataAvailable)
+      } else if (request.error) {
+        computeFetchErrorText(request.error, configuration, onResponseDataAvailable)
+      }
+    }
+
+    function onResponseDataAvailable(responseData) {
+      var urlObj = urlParse(request.url).getParse()
+      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+        rawLogsEvent: {
+          message: format(type) + ' error ' + request.method +' ' + request.url,
+          date: request.startClocks.timeStamp,
+          error: {
+            origin: ErrorSource.NETWORK, // Todo: Remove in the next major release
+            stack: responseData || 'Failed to load',
+          },
+          http: {
+            method: request.method, // Cast resource method because of case mismatch cf issue RUMF-1152
+            status_code: request.status,
+            url: request.url,
+            statusGroup: getStatusGroup(request.status),
+            urlHost: urlObj.Host,
+            urlPath: urlObj.Path,
+            urlPathGroup: replaceNumberCharByPath(urlObj.Path)
+          },
+          status: StatusType.error,
+          origin: ErrorSource.NETWORK,
+        },
+      })
+    }
+  }
+
+  return {
+    stop: function() {
+      xhrSubscription.unsubscribe()
+      fetchSubscription.unsubscribe()
+    },
+  }
+}
+
+// TODO: ideally, computeXhrResponseData should always call the callback with a string instead of
+// `unknown`. But to keep backward compatibility, in the case of XHR with a `responseType` different
+// than "text", the response data should be whatever `xhr.response` is. This is a bit confusing as
+// Logs event 'stack' is expected to be a string. This should be changed in a future major version
+// as it could be a breaking change.
+export function computeXhrResponseData(
+  xhr,
+  configuration,
+  callback
+) {
+  if (typeof xhr.response === 'string') {
+    callback(truncateResponseText(xhr.response, configuration))
+  } else {
+    callback(xhr.response)
+  }
+}
+
+export function computeFetchErrorText(
+  error,
+  configuration,
+  callback
+) {
+  callback(truncateResponseText(toStackTraceString(computeStackTrace(error)), configuration))
+}
+
+export function computeFetchResponseText(
+  response,
+  configuration,
+  callback
+) {
+  if (!window.TextDecoder) {
+    // If the browser doesn't support TextDecoder, let's read the whole response then truncate it.
+    //
+    // This should only be the case on early versions of Edge (before they migrated to Chromium).
+    // Even if it could be possible to implement a workaround for the missing TextDecoder API (using
+    // a Blob and FileReader), we found another issue preventing us from reading only the first
+    // bytes from the response: contrary to other browsers, when reading from the cloned response,
+    // if the original response gets canceled, the cloned response is also canceled and we can't
+    // know about it.  In the following illustration, the promise returned by `reader.read()` may
+    // never be fulfilled:
+    //
+    // fetch('/').then((response) => {
+    //   const reader = response.clone().body.getReader()
+    //   readMore()
+    //   function readMore() {
+    //     reader.read().then(
+    //       (result) => {
+    //         if (result.done) {
+    //           console.log('done')
+    //         } else {
+    //           readMore()
+    //         }
+    //       },
+    //       () => console.log('error')
+    //     )
+    //   }
+    //   response.body.getReader().cancel()
+    // })
+    response
+      .clone()
+      .text()
+      .then(
+        function(text) { return callback(truncateResponseText(text, configuration)) },
+        function(error) { return callback('Unable to retrieve response: ' + error ) }
+      )
+  } else if (!response.body) {
+    callback()
+  } else {
+    truncateResponseStream(
+      response.clone().body,
+      configuration.requestErrorResponseLengthLimit,
+      function(error, responseText){
+        if (error) {
+          callback('Unable to retrieve response: ' + error)
+        } else {
+          callback(responseText)
+        }
+      }
+    )
+  }
+}
+
+function isRejected(request) {
+  return request.status === 0 && request.responseType !== 'opaque'
+}
+
+function isServerError(request) {
+  return request.status >= 500
+}
+
+function truncateResponseText(responseText, configuration) {
+  if (responseText.length > configuration.requestErrorResponseLengthLimit) {
+    return responseText.substring(0, configuration.requestErrorResponseLengthLimit) + '...'
+  }
+  return responseText
+}
+
+function format(type) {
+  if (RequestType.XHR === type) {
+    return 'XHR'
+  }
+  return 'Fetch'
+}
+
+function truncateResponseStream(
+  stream,
+  limit,
+  callback
+) {
+  readLimitedAmountOfBytes(stream, limit, function(error, bytes, limitExceeded){
+    if (error) {
+      callback(error)
+    } else {
+      var responseText = new TextDecoder().decode(bytes)
+      if (limitExceeded) {
+        responseText += '...'
+      }
+      callback(undefined, responseText)
+    }
+  })
+}
+
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+function readLimitedAmountOfBytes(
+  stream,
+  limit,
+  callback
+) {
+  var reader = stream.getReader()
+  var chunks = []
+  var readBytesCount = 0
+
+  readMore()
+
+  function readMore() {
+    reader.read().then(
+      function(result){
+        if (result.done) {
+          onDone()
+          return
+        }
+
+        chunks.push(result.value)
+        readBytesCount += result.value.length
+
+        if (readBytesCount > limit) {
+          onDone()
+        } else {
+          readMore()
+        }
+      },
+      function(error) { return callback(error) }
+    )
+  }
+
+  function onDone() {
+    reader.cancel().catch(
+      // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+      // as an unhandled rejection
+      noop
+    )
+
+    var completeBuffer
+    if (chunks.length === 1) {
+      // optim: if the response is small enough to fit in a single buffer (provided by the browser), just
+      // use it directly.
+      completeBuffer = chunks[0]
+    } else {
+      // else, we need to copy buffers into a larger buffer to concatenate them.
+      completeBuffer = new Uint8Array(readBytesCount)
+      var offset = 0
+      each(chunks, function(chunk) {
+        completeBuffer.set(chunk, offset)
+        offset += chunk.length
+      })
+    }
+    callback(undefined, completeBuffer.slice(0, limit), completeBuffer.length > limit)
+  }
+}

package/src/domain/logsCollection/report/reportCollection.js

@@ -0,0 +1,49 @@
+import {
+  timeStampNow,
+  ErrorSource,
+  RawReportType,
+  getFileFromStackTraceString,
+  initReportObservable,
+  LifeCycleEventType
+} from '@cloudcare/browser-core'
+import { StatusType } from '../../logger'
+
+
+var LogStatusForReport = {
+  [RawReportType.cspViolation]: StatusType.error,
+  [RawReportType.intervention]: StatusType.error,
+  [RawReportType.deprecation]: StatusType.warn,
+}
+
+export function startReportCollection(configuration, lifeCycle) {
+  var reportSubscription = initReportObservable(configuration.forwardReports).subscribe(function(report) {
+    var message = report.message
+    var status = LogStatusForReport[report.type]
+    var error
+    if (status === StatusType.error) {
+      error = {
+        kind: report.subtype,
+        origin: ErrorSource.REPORT, // Todo: Remove in the next major release
+        stack: report.stack,
+      }
+    } else if (report.stack) {
+      message += ' Found in '+ getFileFromStackTraceString(report.stack)
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message: message,
+        origin: ErrorSource.REPORT,
+        error: error,
+        status: status,
+      },
+    })
+  })
+
+  return {
+    stop: function(){
+      reportSubscription.unsubscribe()
+    }
+  }
+}

package/src/domain/logsCollection/rumtimeError/runtimeErrorCollection.js

@@ -0,0 +1,35 @@
+import { noop, ErrorSource, trackRuntimeError, Observable, LifeCycleEventType } from '@cloudcare/browser-core'
+import { StatusType } from '../../logger'
+
+export function startRuntimeErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop }
+  }
+
+  var rawErrorObservable = new Observable()
+
+  var _trackRuntimeError = trackRuntimeError(rawErrorObservable)
+
+  var rawErrorSubscription = rawErrorObservable.subscribe(function(rawError) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: rawError.message,
+        date: rawError.startClocks.timeStamp,
+        error: {
+          kind: rawError.type,
+          origin: ErrorSource.SOURCE, // Todo: Remove in the next major release
+          stack: rawError.stack,
+        },
+        origin: ErrorSource.SOURCE,
+        status: StatusType.error,
+      },
+    })
+  })
+
+  return {
+    stop: function() {
+      _trackRuntimeError.stop()
+      rawErrorSubscription.unsubscribe()
+    },
+  }
+}

package/src/domain/logsSessionManager.js

@@ -0,0 +1,52 @@
+import { performDraw, startSessionManager } from '@cloudcare/browser-core'
+
+export var LOGS_SESSION_KEY = 'logs'
+
+
+export var LoggerTrackingType =  {
+  NOT_TRACKED: '0',
+  TRACKED: '1',
+}
+
+export function startLogsSessionManager(configuration) {
+  var sessionManager = startSessionManager(configuration.cookieOptions, LOGS_SESSION_KEY, function(rawTrackingType) {
+    return computeSessionState(configuration, rawTrackingType)
+  })
+  return {
+    findTrackedSession: function(startTime){
+      var session = sessionManager.findActiveSession(startTime)
+      return session && session.trackingType === LoggerTrackingType.TRACKED
+        ? {
+            id: session.id,
+          }
+        : undefined
+    },
+  }
+}
+
+// export function startLogsSessionManagerStub(configuration) {
+//   var isTracked = computeTrackingType(configuration) === LoggerTrackingType.TRACKED
+//   var session = isTracked ? {} : undefined
+//   return {
+//     findTrackedSession: function() { return session },
+//   }
+// }
+
+function computeTrackingType(configuration) {
+  if (!performDraw(configuration.sampleRate)) {
+    return LoggerTrackingType.NOT_TRACKED
+  }
+  return LoggerTrackingType.TRACKED
+}
+
+function computeSessionState(configuration, rawSessionType) {
+  var trackingType = hasValidLoggerSession(rawSessionType) ? rawSessionType : computeTrackingType(configuration)
+  return {
+    trackingType: trackingType,
+    isTracked: trackingType === LoggerTrackingType.TRACKED,
+  }
+}
+
+function hasValidLoggerSession(trackingType){
+  return trackingType === LoggerTrackingType.NOT_TRACKED || trackingType === LoggerTrackingType.TRACKED
+}

package/src/entries/main.js

@@ -0,0 +1,7 @@
+import { defineGlobal, getGlobalObject } from '@cloudcare/browser-core'
+import { makeLogsPublicApi } from '../boot/logsPublicApi'
+import { startLogs } from '../boot/startLogs'
+
+export const datafluxLogs = makeLogsPublicApi(startLogs)
+
+defineGlobal(getGlobalObject(), 'DATAFLUX_LOGS', datafluxLogs)

package/src/index.js

@@ -1,2 +1,2 @@
-import { datafluxLogs } from './boot/log.entry'
+import { datafluxLogs } from './entries/main'
 export { datafluxLogs }

package/src/transport/startLogsBatch.js

@@ -0,0 +1,17 @@
+import { startBatchWithReplica, LifeCycleEventType } from '@cloudcare/browser-core'
+
+export function startLogsBatch(
+  configuration,
+  lifeCycle,
+  reportError
+) {
+  var batch = startBatchWithReplica(
+    configuration,
+    configuration.logsEndpoint,
+    reportError
+  )
+
+  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, function(serverLogsEvent) {
+    batch.add(serverLogsEvent)
+  })
+}

package/cjs/boot/log.entry.js

@@ -1,115 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.datafluxLogs = void 0;
-exports.makeLogsPublicApi = makeLogsPublicApi;
-
-var _browserCore = require("@cloudcare/browser-core");
-
-var _log = require("./log");
-
-var _logger = require("../domain/logger");
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-var datafluxLogs = makeLogsPublicApi(_log.startLogs);
-exports.datafluxLogs = datafluxLogs;
-(0, _browserCore.defineGlobal)((0, _browserCore.getGlobalObject)(), 'DATAFLUX_LOGS', datafluxLogs);
-
-function makeLogsPublicApi(startLogsImpl) {
-  var isAlreadyInitialized = false;
-  var globalContextManager = (0, _browserCore.createContextManager)();
-  var customLoggers = {};
-  var beforeInitSendLog = new _browserCore.BoundedBuffer();
-
-  var sendLogStrategy = function sendLogStrategy(message, currentContext) {
-    beforeInitSendLog.add([message, currentContext]);
-  };
-
-  var logger = new _logger.Logger(sendLog);
-  return (0, _browserCore.makePublicApi)({
-    logger: logger,
-    init: function init(userConfiguration) {
-      if (!canInitLogs(userConfiguration)) {
-        return;
-      }
-
-      sendLogStrategy = startLogsImpl(userConfiguration, logger, globalContextManager.get);
-      beforeInitSendLog.drain(function (_ref) {
-        var _ref2 = _slicedToArray(_ref, 2),
-            message = _ref2[0],
-            context = _ref2[1];
-
-        return sendLogStrategy(message, context);
-      });
-      isAlreadyInitialized = true;
-    },
-    getLoggerGlobalContext: globalContextManager.get,
-    setLoggerGlobalContext: globalContextManager.set,
-    addLoggerGlobalContext: globalContextManager.add,
-    removeLoggerGlobalContext: globalContextManager.remove,
-    createLogger: function createLogger(name, conf) {
-      if (typeof conf === 'undefined') {
-        conf = {};
-      }
-
-      customLoggers[name] = new _logger.Logger(sendLog, conf.handler, conf.level, (0, _browserCore.extend)({}, conf.context, {
-        logger: {
-          name: name
-        }
-      }));
-      return customLoggers[name];
-    },
-    getLogger: function getLogger(name) {
-      return customLoggers[name];
-    }
-  });
-
-  function canInitLogs(userConfiguration) {
-    if (isAlreadyInitialized) {
-      if (!userConfiguration.silentMultipleInit) {
-        console.error('DATAFLUX_LOGS is already initialized.');
-      }
-
-      return false;
-    }
-
-    if (!userConfiguration.datakitUrl && !userConfiguration.datakitOrigin) {
-      console.error('datakitOrigin is not configured, no RUM data will be collected.');
-      return false;
-    }
-
-    if (userConfiguration.sampleRate !== undefined && !(0, _browserCore.isPercentage)(userConfiguration.sampleRate)) {
-      console.error('Sample Rate should be a number between 0 and 100');
-      return false;
-    }
-
-    return true;
-  }
-
-  function sendLog(message) {
-    sendLogStrategy(message, (0, _browserCore.extend2Lev)({
-      date: new Date().getTime(),
-      view: {
-        referrer: document.referrer,
-        url: window.location.href,
-        host: window.location.host,
-        path: window.location.pathname,
-        pathGroup: (0, _browserCore.replaceNumberCharByPath)(window.location.pathname),
-        urlQuery: (0, _browserCore.jsonStringify)((0, _browserCore.getQueryParamsFromUrl)(window.location.href))
-      }
-    }, globalContextManager.get()));
-  }
-}