@cloudcare/browser-logs 1.1.24 → 1.2.1

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

@@ -0,0 +1,40 @@
+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 stop() {
+      reportSubscription.unsubscribe();
+    }
+  };
+}

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

@@ -0,0 +1,37 @@
+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 stop() {
+      _trackRuntimeError.stop();
+
+      rawErrorSubscription.unsubscribe();
+    }
+  };
+}

package/esm/domain/logsSessionManager.js

@@ -0,0 +1,45 @@
+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 findTrackedSession(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/esm/entries/main.js

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

package/esm/index.js

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

package/esm/transport/startLogsBatch.js

@@ -0,0 +1,7 @@
+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/package.json

@@ -2,9 +2,9 @@
   "name": "@cloudcare/browser-logs",
   "main": "cjs/index.js",
   "module": "esm/index.js",
-  "version": "1.1.24",
+  "version": "1.2.1",
   "dependencies": {
-    "@cloudcare/browser-core": "1.1.3"
+    "@cloudcare/browser-core": "1.2.1"
   },
   "scripts": {
     "dev": "webpack serve --open --mode=development",
@@ -28,5 +28,5 @@
   "author": "dataflux",
   "license": "MIT",
   "description": "DataFlux RUM Web 端数据指标监控",
-  "gitHead": "8cd2d38961b7663bde39072730de22bcf4ba9c2b"
+  "gitHead": "e8411cbf5448e90b81a5e902c54cceb44e6e2501"
 }

package/src/boot/logsPublicApi.js

@@ -0,0 +1,140 @@
+import {
+  BoundedBuffer,
+  createContextManager,
+  makePublicApi,
+  display,
+  deepClone,
+  timeStampNow,
+} from '@cloudcare/browser-core'
+import { validateAndBuildLogsConfiguration } from '../domain/configuration'
+import { Logger } from '../domain/logger'
+
+export function makeLogsPublicApi(startLogsImpl) {
+  var isAlreadyInitialized = false
+
+  var globalContextManager = createContextManager()
+  var customLoggers = {}
+  var getInternalContextStrategy = function() {
+    return undefined
+  }
+
+  var beforeInitLoggerLog = new BoundedBuffer()
+
+  var handleLogStrategy = function(
+    logsMessage,
+    logger,
+    savedCommonContext,
+    date
+  ){
+    if (typeof savedCommonContext === 'undefined') {
+      savedCommonContext = deepClone(getCommonContext())
+    }
+    if (typeof date === 'undefined') {
+      date = timeStampNow()
+    }
+    beforeInitLoggerLog.add(function() {
+      return handleLogStrategy(logsMessage, logger, savedCommonContext, date)
+    })
+  }
+
+  var getInitConfigurationStrategy = function() {
+    return undefined
+  }
+
+  var mainLogger = new Logger(function() {
+    return handleLogStrategy.apply(this, arguments)
+  })
+
+  function getCommonContext() {
+    return {
+      view: {
+        referrer: document.referrer,
+        url: window.location.href,
+      },
+      context: globalContextManager.get(),
+    }
+  }
+
+  return makePublicApi({
+    logger: mainLogger,
+
+    init: function(initConfiguration) {
+      if (!canInitLogs(initConfiguration)) {
+        return
+      }
+
+      var configuration = validateAndBuildLogsConfiguration(initConfiguration)
+      if (!configuration) {
+        return
+      }
+      var _startLogsImpl = startLogsImpl(configuration, getCommonContext, mainLogger)
+      handleLogStrategy = _startLogsImpl.handleLog
+      getInternalContextStrategy = _startLogsImpl.getInternalContext
+      getInitConfigurationStrategy = function() {
+        return deepClone(initConfiguration)
+      }
+      beforeInitLoggerLog.drain()
+
+      isAlreadyInitialized = true
+    },
+
+    /** @deprecated: use getGlobalContext instead */
+    getGlobalContext: globalContextManager.getContext,
+
+    /** @deprecated: use setGlobalContext instead */
+    setGlobalContext: globalContextManager.setContext,
+
+    /** @deprecated: use setGlobalContextProperty instead */
+    setGlobalContextProperty: globalContextManager.setContextProperty,
+
+    /** @deprecated: use removeGlobalContextProperty instead */
+    removeGlobalContextProperty: globalContextManager.removeContextProperty,
+
+    clearGlobalContext: globalContextManager.clearContext,
+
+    createLogger: function(name, conf){
+      if (typeof conf == 'undefined') {
+        conf = {}
+      }
+      customLoggers[name] = new Logger(
+        function() {
+          return handleLogStrategy(this. arguments)
+        },
+        name,
+        conf.handler,
+        conf.level,
+        conf.context
+      )
+      return customLoggers[name]
+    },
+
+    getLogger: function(name) {
+      return customLoggers[name]
+    },
+
+    getInitConfiguration: function() {
+      return getInitConfigurationStrategy()
+    },
+
+    getInternalContext: function(startTime) {
+      return getInternalContextStrategy(startTime)
+    },
+  })
+
+
+  function canInitLogs(initConfiguration) {
+    if (isAlreadyInitialized) {
+      if (!initConfiguration.silentMultipleInit) {
+        display.error('DD_LOGS is already initialized.')
+      }
+      return false
+    }
+    if (!initConfiguration.datakitUrl && !initConfiguration.datakitOrigin) {
+      display.error(
+        'datakitOrigin is not configured, no RUM data will be collected.'
+      )
+      return false
+    }
+    return true
+  }
+}

package/src/boot/startLogs.js

@@ -0,0 +1,51 @@
+import {
+  ErrorSource,
+  LifeCycle, 
+  LifeCycleEventType
+} from '@cloudcare/browser-core'
+import { startLogsSessionManager } from '../domain/logsSessionManager'
+import { startLogsAssembly } from '../domain/assembly'
+import { startConsoleCollection } from '../domain/logsCollection/console/consoleCollection'
+import { startReportCollection } from '../domain/logsCollection/report/reportCollection'
+import { startNetworkErrorCollection } from '../domain/logsCollection/networkError/networkErrorCollection'
+import { startRuntimeErrorCollection } from '../domain/logsCollection/rumtimeError/runtimeErrorCollection'
+import { startLoggerCollection } from '../domain/logsCollection/logger/loggerCollection'
+import { startLogsBatch } from '../transport/startLogsBatch'
+import { StatusType } from '../domain/logger'
+import { startInternalContext } from '../domain/internalContext'
+
+export function startLogs(configuration, getCommonContext, mainLogger) {
+  var lifeCycle = new LifeCycle()
+
+  const reportError = function(error) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: error.message,
+        date: error.startClocks.timeStamp,
+        error: {
+          origin: ErrorSource.AGENT, // Todo: Remove in the next major release
+        },
+        origin: ErrorSource.AGENT,
+        status: StatusType.error,
+      },
+    })
+  }
+  startNetworkErrorCollection(configuration, lifeCycle)
+  startRuntimeErrorCollection(configuration, lifeCycle)
+  startConsoleCollection(configuration, lifeCycle)
+  startReportCollection(configuration, lifeCycle)
+  var _startLoggerCollection = startLoggerCollection(lifeCycle)
+
+  var session = startLogsSessionManager(configuration)
+  startLogsAssembly(session, configuration, lifeCycle, getCommonContext, mainLogger, reportError)
+
+  startLogsBatch(configuration, lifeCycle, reportError)
+
+  var internalContext = startInternalContext(session)
+
+  return {
+    handleLog: _startLoggerCollection.handleLog,
+    getInternalContext: internalContext.get,
+  }
+}
+

package/src/domain/assembly.js

@@ -0,0 +1,101 @@
+import {
+  ErrorSource,
+  extend2Lev,
+  createEventRateLimiter,
+  getRelativeTime,
+  withSnakeCaseKeys,
+  LifeCycleEventType,
+  deviceInfo,
+  each,
+  RumEventType,
+  isNullUndefinedDefaultValue
+} from '@cloudcare/browser-core'
+
+import { STATUSES, HandlerType } from './logger'
+import { isAuthorized } from './logsCollection/logger/loggerCollection'
+
+export function startLogsAssembly(
+  sessionManager,
+  configuration,
+  lifeCycle,
+  getCommonContext,
+  mainLogger,
+  reportError
+) {
+  var statusWithCustom = STATUSES.concat(['custom'])
+  var logRateLimiters = {}
+  each(statusWithCustom, function(status) {
+    logRateLimiters[status] = createEventRateLimiter(status, configuration.eventRateLimiterThreshold, reportError)
+  })
+  lifeCycle.subscribe(
+    LifeCycleEventType.RAW_LOG_COLLECTED,
+    function(data) {
+      // { rawLogsEvent, messageContext = undefined, savedCommonContext = undefined, logger = mainLogger }
+      var rawLogsEvent = data.rawLogsEvent
+      var messageContext = data.messageContext || undefined
+      var savedCommonContext = data.messageContext || undefined
+      var logger = data.logger || mainLogger
+      var startTime = getRelativeTime(rawLogsEvent.date)
+      var session = sessionManager.findTrackedSession(startTime)
+
+      if (!session) {
+        return
+      }
+      var commonContext = savedCommonContext || getCommonContext()
+      var log = extend2Lev(
+        { 
+          service: configuration.service || 'browser', 
+          env: configuration.env || '',
+          version: configuration.version || '',
+          _dd: {
+            sdkName: configuration.sdkName,
+            sdkVersion: configuration.sdkVersion,
+          },
+          session: {
+            id: session.id
+          }, 
+          view: commonContext.view,
+          device: deviceInfo,
+          type: RumEventType.LOGGER
+        },
+        commonContext.context,
+        getRUMInternalContext(startTime),
+        rawLogsEvent,
+        logger.getContext(),
+        messageContext
+      )
+
+      if (
+        // Todo: [RUMF-1230] Move this check to the logger collection in the next major release
+        !isAuthorized(rawLogsEvent.status, HandlerType.http, logger) || (configuration.beforeSend && configuration.beforeSend(log) === false)
+        ||
+        (
+          log.error 
+          && 
+          log.error.origin !== ErrorSource.AGENT 
+          &&
+          isNullUndefinedDefaultValue(logRateLimiters[log.status], logRateLimiters['custom']).isLimitReached()
+        )
+      ) {
+        return
+      }
+
+      lifeCycle.notify(LifeCycleEventType.LOG_COLLECTED, withSnakeCaseKeys(log))
+    }
+  )
+}
+
+
+export function getRUMInternalContext(startTime) {
+  return getInternalContextFromRumGlobal(window.DATAFLUX_RUM)
+
+  function getInternalContextFromRumGlobal(rumGlobal) {
+    if (rumGlobal && rumGlobal.getInternalContext) {
+      return rumGlobal.getInternalContext(startTime)
+    }
+  }
+}
+
+export function resetRUMInternalContext() {
+  logsSentBeforeRumInjectionTelemetryAdded = false
+}

package/src/domain/configuration.js

@@ -0,0 +1,70 @@
+import {
+  assign,
+  ONE_KIBI_BYTE,
+  validateAndBuildConfiguration,
+  display,
+  unique,
+  RawReportType,
+  isArray,
+  every,
+  ConsoleApiName,
+  includes,
+  values,
+} from '@cloudcare/browser-core'
+import { buildEnv } from '../boot/buildEnv'
+/**
+ * arbitrary value, byte precision not needed
+ */
+export var DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE
+
+export function validateAndBuildLogsConfiguration(
+  initConfiguration
+){
+  var baseConfiguration = validateAndBuildConfiguration(initConfiguration)
+
+  var forwardConsoleLogs = validateAndBuildForwardOption(
+    initConfiguration.forwardConsoleLogs,
+    values(ConsoleApiName),
+    'Forward Console Logs'
+  )
+
+  var forwardReports = validateAndBuildForwardOption(
+    initConfiguration.forwardReports,
+    values(RawReportType),
+    'Forward Reports'
+  )
+
+  if (!baseConfiguration || !forwardConsoleLogs || !forwardReports) {
+    return
+  }
+
+  if (initConfiguration.forwardErrorsToLogs && !includes(forwardConsoleLogs, ConsoleApiName.error)) {
+    forwardConsoleLogs.push(ConsoleApiName.error)
+  }
+  return assign(
+    {
+      forwardErrorsToLogs: initConfiguration.forwardErrorsToLogs !== false,
+      forwardConsoleLogs: forwardConsoleLogs,
+      forwardReports: forwardReports,
+      requestErrorResponseLengthLimit: DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT,
+    },
+    baseConfiguration,
+    buildEnv
+  )
+}
+
+export function validateAndBuildForwardOption(
+  option,
+  allowedValues,
+  label
+) {
+  if (option === undefined) {
+    return []
+  }
+
+  if (!(option === 'all' || (isArray(option) && every(option, function(api) { return includes(allowedValues, api) })))) {
+    display.error(label + ' should be "all" or an array with allowed values "' + allowedValues.join('", "') + '"')
+    return
+  }
+  return option === 'all' ? allowedValues : unique(option)
+}

package/src/domain/internalContext.js

@@ -0,0 +1,15 @@
+
+export function startInternalContext(sessionManager) {
+  return {
+    get: function(startTime) {
+      var trackedSession = sessionManager.findTrackedSession(startTime)
+      if (trackedSession) {
+        return {
+          session: {
+            id: trackedSession.id
+          },
+        }
+      }
+    },
+  }
+}

package/src/domain/logger.js

@@ -1,36 +1,23 @@
-import {
-  createContextManager,
-  extend2Lev,
-  keys,
-  ErrorSource,
-  jsonStringify
-} from '@cloudcare/browser-core'
+import { deepClone, assign, extend2Lev, createContextManager, ErrorSource, keys } from '@cloudcare/browser-core'
+
+
 export var StatusType = {
   debug: 'debug',
-  critical: 'critical',
   error: 'error',
   info: 'info',
-  warn: 'warning'
+  warn: 'warn',
+  critical: 'critical'
 }
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 
-var STATUS_PRIORITIES = {
-  [StatusType.debug]: 0,
-  [StatusType.info]: 1,
-  [StatusType.warn]: 2,
-  [StatusType.error]: 3,
-  [StatusType.critical]: 4
-}
-
-export const STATUSES = keys(StatusType)
-
-export const HandlerType = {
+export var HandlerType = {
   console: 'console',
   http: 'http',
-  silent: 'silent'
+  silent: 'silent',
 }
+
+export var STATUSES = keys(StatusType)
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-export function Logger(sendLog, handlerType, level, loggerContext) {
+export function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {
   this.contextManager = createContextManager()
   if (typeof handlerType === 'undefined') {
     handlerType = HandlerType.http
@@ -41,77 +28,69 @@ export function Logger(sendLog, handlerType, level, loggerContext) {
   if (typeof loggerContext === 'undefined') {
     loggerContext = {}
   }
-  this.sendLog = sendLog
+  this.handleLogStrategy = handleLogStrategy
   this.handlerType = handlerType
   this.level = level
-  this.contextManager.set(loggerContext)
+  this.contextManager.set(assign({}, loggerContext, name ? { logger: { name: name } } : undefined))
 }
 Logger.prototype = {
-  log: function (message, messageContext, status) {
+  log: function(message, messageContext, status) {
     if (typeof status === 'undefined') {
       status = StatusType.info
     }
-    if (STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[this.level]) {
-      switch (this.handlerType) {
-        case HandlerType.http:
-          var logMessage = extend2Lev(
-            { message: message, status: status },
-            { tags: this.contextManager.get() },
-            messageContext
-          )
-          this.sendLog(logMessage)
-          break
-        case HandlerType.console:
-          console.log(
-            status + ' : ' + message,
-            extend2Lev(this.contextManager.get(), messageContext)
-          )
-          break
-        case HandlerType.silent:
-          break
-      }
-    }
+    this.handleLogStrategy({ message: message, context: deepClone(messageContext), status:status }, this)
   },
-  debug: function (message, messageContext) {
+
+  debug: function(message, messageContext) {
     this.log(message, messageContext, StatusType.debug)
   },
 
-  info: function (message, messageContext) {
+  info: function(message, messageContext) {
     this.log(message, messageContext, StatusType.info)
   },
 
-  warn: function (message, messageContext) {
+  warn: function(message, messageContext) {
     this.log(message, messageContext, StatusType.warn)
   },
-  critical: function (message, messageContext) {
+  critical: function(message, messageContext) {
     this.log(message, messageContext, StatusType.critical)
   },
-  error: function (message, messageContext) {
+  error: function(message, messageContext) {
     var errorOrigin = {
       error: {
-        origin: ErrorSource.LOGGER
-      }
+        origin: ErrorSource.LOGGER,
+      },
     }
     this.log(message, extend2Lev(errorOrigin, messageContext), StatusType.error)
   },
 
-  setContext: function (context) {
+  setContext:function(context) {
     this.contextManager.set(context)
   },
 
-  addContext: function (key, value) {
+  getContext: function() {
+    return this.contextManager.get()
+  },
+
+  addContext: function(key, value) {
     this.contextManager.add(key, value)
   },
 
-  removeContext: function (key) {
+  removeContext: function(key) {
     this.contextManager.remove(key)
   },
 
-  setHandler: function (handler) {
+  setHandler:function(handler) {
     this.handlerType = handler
   },
 
-  setLevel: function (level) {
+  getHandler: function() {
+    return this.handlerType
+  },
+  setLevel: function(level) {
     this.level = level
+  },
+  getLevel: function() {
+    return this.level
   }
 }