@cloudcare/browser-logs 2.0.5 → 2.0.7

package/esm/domain/assembly.js

@@ -1,7 +1,7 @@
-import { ErrorSource, extend2Lev, createEventRateLimiter, getRelativeTime, withSnakeCaseKeys, LifeCycleEventType, deviceInfo, each, RumEventType, isNullUndefinedDefaultValue } from '@cloudcare/browser-core';
+import { ErrorSource, extend2Lev, createEventRateLimiter, getRelativeTime, withSnakeCaseKeys, LifeCycleEventType, deviceInfo, each, RumEventType, isEmptyObject, 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) {
+export function startLogsAssembly(sessionManager, configuration, lifeCycle, buildCommonContext, mainLogger, reportError) {
   var statusWithCustom = STATUSES.concat(['custom']);
   var logRateLimiters = {};
   each(statusWithCustom, function (status) {
@@ -11,7 +11,7 @@ export function startLogsAssembly(sessionManager, configuration, lifeCycle, getC
     // { rawLogsEvent, messageContext = undefined, savedCommonContext = undefined, logger = mainLogger }
     var rawLogsEvent = data.rawLogsEvent;
     var messageContext = data.messageContext || undefined;
-    var savedCommonContext = data.messageContext || undefined;
+    var savedCommonContext = data.savedCommonContext || undefined;
     var logger = data.logger || mainLogger;
     var startTime = getRelativeTime(rawLogsEvent.date);
     var session = sessionManager.findTrackedSession(startTime);
@@ -20,7 +20,7 @@ export function startLogsAssembly(sessionManager, configuration, lifeCycle, getC
       return;
     }
 
-    var commonContext = savedCommonContext || getCommonContext();
+    var commonContext = savedCommonContext || buildCommonContext();
     var log = extend2Lev({
       service: configuration.service || 'browser',
       env: configuration.env || '',
@@ -33,6 +33,7 @@ export function startLogsAssembly(sessionManager, configuration, lifeCycle, getC
         id: session.id
       },
       view: commonContext.view,
+      user: !isEmptyObject(commonContext.user) ? commonContext.user : undefined,
       device: deviceInfo,
       type: RumEventType.LOGGER
     }, commonContext.context, getRUMInternalContext(startTime), rawLogsEvent, logger.getContext(), messageContext);

package/esm/domain/logger.js

@@ -1,4 +1,4 @@
-import { deepClone, assign, extend2Lev, createContextManager, ErrorSource, keys } from '@cloudcare/browser-core';
+import { deepClone, assign, extend2Lev, createContextManager, ErrorSource, keys, CustomerDataType } from '@cloudcare/browser-core';
 export var StatusType = {
   debug: 'debug',
   error: 'error',
@@ -14,7 +14,7 @@ export var HandlerType = {
 export var STATUSES = keys(StatusType); // eslint-disable-next-line @typescript-eslint/no-redeclare
 
 export function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {
-  this.contextManager = createContextManager();
+  this.contextManager = createContextManager(CustomerDataType.LoggerContext);
 
   if (typeof handlerType === 'undefined') {
     handlerType = HandlerType.http;

package/esm/domain/logsSessionManager.js

@@ -1,4 +1,4 @@
-import { performDraw, startSessionManager } from '@cloudcare/browser-core';
+import { performDraw, startSessionManager, Observable } from '@cloudcare/browser-core';
 export var LOGS_SESSION_KEY = 'logs';
 export var LoggerTrackingType = {
   NOT_TRACKED: '0',
@@ -14,15 +14,20 @@ export function startLogsSessionManager(configuration) {
       return session && session.trackingType === LoggerTrackingType.TRACKED ? {
         id: session.id
       } : undefined;
-    }
+    },
+    expireObservable: sessionManager.expireObservable
   };
-} // export function startLogsSessionManagerStub(configuration) {
-//   var isTracked = computeTrackingType(configuration) === LoggerTrackingType.TRACKED
-//   var session = isTracked ? {} : undefined
-//   return {
-//     findTrackedSession: function() { return session },
-//   }
-// }
+}
+export function startLogsSessionManagerStub(configuration) {
+  var isTracked = computeTrackingType(configuration) === LoggerTrackingType.TRACKED;
+  var session = isTracked ? {} : undefined;
+  return {
+    findTrackedSession: function findTrackedSession() {
+      return session;
+    },
+    expireObservable: new Observable()
+  };
+}
 
 function computeTrackingType(configuration) {
   if (!performDraw(configuration.sessionSampleRate)) {

package/esm/transport/startLogsBatch.js

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

package/package.json

@@ -1,32 +1,32 @@
 {
-  "name": "@cloudcare/browser-logs",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "version": "2.0.5",
-  "dependencies": {
-    "@cloudcare/browser-core": "2.0.4"
-  },
-  "scripts": {
-    "dev": "webpack serve --open --mode=development",
-    "build": "run-p build:cjs build:esm build:bundle",
-    "build:cjs": "rm -rf cjs && babel --config-file ./babel.cjs.json --out-dir cjs ./src && npm run replace-build-env cjs",
-    "build:esm": "rm -rf esm && babel --config-file ./babel.esm.json --out-dir esm ./src && npm run replace-build-env esm",
-    "build:bundle": "rm -rf bundle && webpack --config webpack.config.js --mode=production && npm run replace-build-env bundle ",
-    "publish:oss": "npm run build && node ./scripts/publish-oss.js",
-    "publish:oss:test": "npm run build && node ./scripts/publish-oss.js test",
-    "replace-build-env": "node scripts/replace-build-env.js"
-  },
-  "keywords": [
-    "dataflux",
-    "logs",
-    "sdk"
-  ],
-  "repository": {
-    "url": "https://github.com/DataFlux-cn/datakit-js",
-    "type": "git"
-  },
-  "author": "dataflux",
-  "license": "MIT",
-  "description": "DataFlux RUM Web 端数据指标监控",
-  "gitHead": "c8c2e9dfd59732cdadc5c7869eba9d7ddf6abeb2"
+    "name": "@cloudcare/browser-logs",
+    "main": "cjs/index.js",
+    "module": "esm/index.js",
+    "version": "2.0.7",
+    "dependencies": {
+        "@cloudcare/browser-core": "2.0.6"
+    },
+    "scripts": {
+        "dev": "webpack serve --open --mode=development",
+        "build": "run-p build:cjs build:esm build:bundle",
+        "build:cjs": "rm -rf cjs && babel --config-file ./babel.cjs.json --out-dir cjs ./src && npm run replace-build-env cjs",
+        "build:esm": "rm -rf esm && babel --config-file ./babel.esm.json --out-dir esm ./src && npm run replace-build-env esm",
+        "build:bundle": "rm -rf bundle && webpack --config webpack.config.js --mode=production && npm run replace-build-env bundle ",
+        "publish:oss": "npm run build && node ./scripts/publish-oss.js",
+        "publish:oss:test": "npm run build && node ./scripts/publish-oss.js test",
+        "replace-build-env": "node scripts/replace-build-env.js"
+    },
+    "keywords": [
+        "dataflux",
+        "logs",
+        "sdk"
+    ],
+    "repository": {
+        "url": "https://github.com/DataFlux-cn/datakit-js",
+        "type": "git"
+    },
+    "author": "dataflux",
+    "license": "MIT",
+    "description": "DataFlux RUM Web 端数据指标监控",
+    "gitHead": "ffbab227685c4ea3bf9b26e6e5e9c00233e64bb2"
 }

package/src/boot/logsPublicApi.js

@@ -2,9 +2,12 @@ import {
   BoundedBuffer,
   createContextManager,
   makePublicApi,
+  CustomerDataType,
   display,
   deepClone,
   timeStampNow,
+  checkUser,
+  sanitizeUser
 } from '@cloudcare/browser-core'
 import { validateAndBuildLogsConfiguration } from '../domain/configuration'
 import { Logger } from '../domain/logger'
@@ -12,53 +15,57 @@ import { Logger } from '../domain/logger'
 export function makeLogsPublicApi(startLogsImpl) {
   var isAlreadyInitialized = false
 
-  var globalContextManager = createContextManager()
+  var globalContextManager = createContextManager(
+    CustomerDataType.GlobalContext
+  )
+  var userContextManager = createContextManager(CustomerDataType.User)
   var customLoggers = {}
-  var getInternalContextStrategy = function() {
+  var getInternalContextStrategy = function () {
     return undefined
   }
 
   var beforeInitLoggerLog = new BoundedBuffer()
 
-  var handleLogStrategy = function(
+  var handleLogStrategy = function (
     logsMessage,
     logger,
     savedCommonContext,
     date
-  ){
+  ) {
     if (typeof savedCommonContext === 'undefined') {
-      savedCommonContext = deepClone(getCommonContext())
+      savedCommonContext = deepClone(buildCommonContext())
     }
     if (typeof date === 'undefined') {
       date = timeStampNow()
     }
-    beforeInitLoggerLog.add(function() {
+    beforeInitLoggerLog.add(function () {
       return handleLogStrategy(logsMessage, logger, savedCommonContext, date)
     })
   }
 
-  var getInitConfigurationStrategy = function() {
+  var getInitConfigurationStrategy = function () {
     return undefined
   }
 
-  var mainLogger = new Logger(function() {
+  var mainLogger = new Logger(function () {
     return handleLogStrategy.apply(this, arguments)
   })
 
-  function getCommonContext() {
+  function buildCommonContext() {
     return {
       view: {
         referrer: document.referrer,
-        url: window.location.href,
+        url: window.location.href
       },
-      context: globalContextManager.get(),
+      context: globalContextManager.getContext(),
+      user: userContextManager.getContext()
     }
   }
 
   return makePublicApi({
     logger: mainLogger,
 
-    init: function(initConfiguration) {
+    init: function (initConfiguration) {
       if (!canInitLogs(initConfiguration)) {
         return
       }
@@ -67,10 +74,14 @@ export function makeLogsPublicApi(startLogsImpl) {
       if (!configuration) {
         return
       }
-      var _startLogsImpl = startLogsImpl(configuration, getCommonContext, mainLogger)
+      var _startLogsImpl = startLogsImpl(
+        configuration,
+        buildCommonContext,
+        mainLogger
+      )
       handleLogStrategy = _startLogsImpl.handleLog
       getInternalContextStrategy = _startLogsImpl.getInternalContext
-      getInitConfigurationStrategy = function() {
+      getInitConfigurationStrategy = function () {
         return deepClone(initConfiguration)
       }
       beforeInitLoggerLog.drain()
@@ -92,13 +103,13 @@ export function makeLogsPublicApi(startLogsImpl) {
 
     clearGlobalContext: globalContextManager.clearContext,
 
-    createLogger: function(name, conf){
+    createLogger: function (name, conf) {
       if (typeof conf == 'undefined') {
         conf = {}
       }
       customLoggers[name] = new Logger(
-        function() {
-          return handleLogStrategy(this. arguments)
+        function () {
+          return handleLogStrategy(this.arguments)
         },
         name,
         conf.handler,
@@ -108,20 +119,27 @@ export function makeLogsPublicApi(startLogsImpl) {
       return customLoggers[name]
     },
 
-    getLogger: function(name) {
+    getLogger: function (name) {
       return customLoggers[name]
     },
 
-    getInitConfiguration: function() {
+    getInitConfiguration: function () {
       return getInitConfigurationStrategy()
     },
 
-    getInternalContext: function(startTime) {
+    getInternalContext: function (startTime) {
       return getInternalContextStrategy(startTime)
     },
+    setUser: function (newUser) {
+      if (checkUser(newUser)) {
+        userContextManager.setContext(sanitizeUser(newUser))
+      }
+    },
+    getUser: userContextManager.getContext,
+    removeUserProperty: userContextManager.removeContextProperty,
+    clearUser: userContextManager.clearContext
   })
 
-
   function canInitLogs(initConfiguration) {
     if (isAlreadyInitialized) {
       if (!initConfiguration.silentMultipleInit) {

package/src/boot/startLogs.js

@@ -2,9 +2,13 @@ import {
   ErrorSource,
   LifeCycle,
   LifeCycleEventType,
-  createPageExitObservable
+  createPageExitObservable,
+  areCookiesAuthorized
 } from '@cloudcare/browser-core'
-import { startLogsSessionManager } from '../domain/logsSessionManager'
+import {
+  startLogsSessionManager,
+  startLogsSessionManagerStub
+} from '../domain/logsSessionManager'
 import { startLogsAssembly } from '../domain/assembly'
 import { startConsoleCollection } from '../domain/logsCollection/console/consoleCollection'
 import { startReportCollection } from '../domain/logsCollection/report/reportCollection'
@@ -15,7 +19,7 @@ import { startLogsBatch } from '../transport/startLogsBatch'
 import { StatusType } from '../domain/logger'
 import { startInternalContext } from '../domain/internalContext'
 
-export function startLogs(configuration, getCommonContext, mainLogger) {
+export function startLogs(configuration, buildCommonContext, mainLogger) {
   var lifeCycle = new LifeCycle()
 
   var reportError = function (error) {
@@ -32,23 +36,31 @@ export function startLogs(configuration, getCommonContext, mainLogger) {
     })
   }
   var pageExitObservable = createPageExitObservable()
+  var session = areCookiesAuthorized(configuration.cookieOptions)
+    ? startLogsSessionManager(configuration)
+    : startLogsSessionManagerStub(configuration)
   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,
+    buildCommonContext,
     mainLogger,
     reportError
   )
 
-  startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable)
+  startLogsBatch(
+    configuration,
+    lifeCycle,
+    reportError,
+    pageExitObservable,
+    session.expireObservable
+  )
 
   var internalContext = startInternalContext(session)
 

package/src/domain/assembly.js

@@ -8,6 +8,7 @@ import {
   deviceInfo,
   each,
   RumEventType,
+  isEmptyObject,
   isNullUndefinedDefaultValue
 } from '@cloudcare/browser-core'
 
@@ -18,73 +19,75 @@ export function startLogsAssembly(
   sessionManager,
   configuration,
   lifeCycle,
-  getCommonContext,
+  buildCommonContext,
   mainLogger,
   reportError
 ) {
   var statusWithCustom = STATUSES.concat(['custom'])
   var logRateLimiters = {}
-  each(statusWithCustom, function(status) {
-    logRateLimiters[status] = createEventRateLimiter(status, configuration.eventRateLimiterThreshold, reportError)
+  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)
+  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.savedCommonContext || 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
+    if (!session) {
+      return
+    }
+    var commonContext = savedCommonContext || buildCommonContext()
+    var log = extend2Lev(
+      {
+        service: configuration.service || 'browser',
+        env: configuration.env || '',
+        version: configuration.version || '',
+        _dd: {
+          sdkName: configuration.sdkName,
+          sdkVersion: configuration.sdkVersion
         },
-        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
-      }
+        session: {
+          id: session.id
+        },
+        view: commonContext.view,
+        user: !isEmptyObject(commonContext.user)
+          ? commonContext.user
+          : undefined,
+        device: deviceInfo,
+        type: RumEventType.LOGGER
+      },
+      commonContext.context,
+      getRUMInternalContext(startTime),
+      rawLogsEvent,
+      logger.getContext(),
+      messageContext
+    )
 
-      lifeCycle.notify(LifeCycleEventType.LOG_COLLECTED, withSnakeCaseKeys(log))
+    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)

package/src/domain/logger.js

@@ -1,5 +1,12 @@
-import { deepClone, assign, extend2Lev, createContextManager, ErrorSource, keys } from '@cloudcare/browser-core'
-
+import {
+  deepClone,
+  assign,
+  extend2Lev,
+  createContextManager,
+  ErrorSource,
+  keys,
+  CustomerDataType
+} from '@cloudcare/browser-core'
 
 export var StatusType = {
   debug: 'debug',
@@ -12,13 +19,19 @@ export var StatusType = {
 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(handleLogStrategy, name, handlerType, level, loggerContext) {
-  this.contextManager = createContextManager()
+export function Logger(
+  handleLogStrategy,
+  name,
+  handlerType,
+  level,
+  loggerContext
+) {
+  this.contextManager = createContextManager(CustomerDataType.LoggerContext)
   if (typeof handlerType === 'undefined') {
     handlerType = HandlerType.http
   }
@@ -31,66 +44,71 @@ export function Logger(handleLogStrategy, name, handlerType, level, loggerContex
   this.handleLogStrategy = handleLogStrategy
   this.handlerType = handlerType
   this.level = level
-  this.contextManager.set(assign({}, loggerContext, name ? { logger: { name: name } } : undefined))
+  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
     }
-    this.handleLogStrategy({ message: message, context: deepClone(messageContext), status:status }, this)
+    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)
   },
 
-  getContext: function() {
+  getContext: function () {
     return this.contextManager.get()
   },
 
-  addContext: function(key, value) {
+  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
   },
 
-  getHandler: function() {
+  getHandler: function () {
     return this.handlerType
   },
-  setLevel: function(level) {
+  setLevel: function (level) {
     this.level = level
   },
-  getLevel: function() {
+  getLevel: function () {
     return this.level
   }
 }