@cloudcare/rum-uniapp 1.0.3 → 2.0.1

package/cjs/rumEventsCollection/assembly.js

@@ -24,17 +24,20 @@ var SessionType = {
   USER: 'user'
 };
 
-function startRumAssembly(applicationId, configuration, lifeCycle, parentContexts) {
+function startRumAssembly(applicationId, configuration, lifeCycle, parentContexts, getCommonContext) {
   lifeCycle.subscribe(_lifeCycle.LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, function (data) {
     var startTime = data.startTime;
     var rawRumEvent = data.rawRumEvent;
     var viewContext = parentContexts.findView(startTime);
+    var savedCommonContext = data.savedGlobalContext;
+    var customerContext = data.customerContext;
     var deviceContext = {
       device: _baseInfo["default"].deviceInfo
     };
 
     if (isTracked(configuration) && (viewContext || rawRumEvent.type === _enums.RumEventType.APP)) {
       var actionContext = parentContexts.findAction(startTime);
+      var commonContext = savedCommonContext || getCommonContext();
       var rumContext = {
         _dd: {
           sdkName: configuration.sdkName,
@@ -53,12 +56,26 @@ function startRumAssembly(applicationId, configuration, lifeCycle, parentContext
           type: SessionType.USER
         },
         user: {
-          user_id: configuration.user_id || _baseInfo["default"].getClientID(),
+          id: configuration.user_id || _baseInfo["default"].getClientID(),
           is_signin: configuration.user_id ? 'T' : 'F'
         }
       };
       var rumEvent = (0, _utils.extend2Lev)(rumContext, deviceContext, viewContext, actionContext, rawRumEvent);
       var serverRumEvent = (0, _utils.withSnakeCaseKeys)(rumEvent);
+      var context = (0, _utils.extend2Lev)(commonContext.context, customerContext);
+
+      if (!(0, _utils.isEmptyObject)(context)) {
+        serverRumEvent.tags = context;
+      }
+
+      if (!(0, _utils.isEmptyObject)(commonContext.user)) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        serverRumEvent.user = (0, _utils.extend2Lev)({
+          id: _baseInfo["default"].getClientID(),
+          is_signin: 'T'
+        }, commonContext.user);
+      }
+
       lifeCycle.notify(_lifeCycle.LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent);
     }
   });

package/cjs/rumEventsCollection/page/index.js

@@ -36,7 +36,7 @@ function rewritePage(configuration, lifeCycle, Vue) {
 
         if (methodName === 'onShow' || methodName === 'onLoad') {
           if (typeof currentView === 'undefined') {
-            var activePage = getActivePage();
+            var activePage = (0, _utils.getActivePage)();
             currentView = newView(lifeCycle, activePage && activePage.route, startTime);
           }
         }
@@ -231,14 +231,4 @@ function trackSetDataTime(lifeCycle, callback) {
   return {
     stop: subscribe.unsubscribe
   };
-}
-
-function getActivePage() {
-  var curPages = getCurrentPages();
-
-  if (curPages.length) {
-    return curPages[curPages.length - 1];
-  }
-
-  return {};
 }

package/cjs/rumEventsCollection/requestCollection.js

@@ -17,10 +17,13 @@ var _utils = require("../helper/utils");
 
 var _resourceUtils = require("../rumEventsCollection/resource/resourceUtils");
 
+var _tracer = require("../rumEventsCollection/tracing/tracer");
+
 var nextRequestIndex = 1;
 
 function startRequestCollection(lifeCycle, configuration) {
-  trackXhr(lifeCycle, configuration);
+  var tracer = (0, _tracer.startTracer)(configuration);
+  trackXhr(lifeCycle, configuration, tracer);
   trackDownload(lifeCycle, configuration);
 }
 
@@ -43,10 +46,11 @@ function getHeaderString(header) {
   return headerStr;
 }
 
-function trackXhr(lifeCycle, configuration) {
+function trackXhr(lifeCycle, configuration, tracer) {
   var xhrProxy = (0, _xhrProxy.startXhrProxy)();
   xhrProxy.beforeSend(function (context) {
     if ((0, _resourceUtils.isAllowedRequestUrl)(configuration, context.url)) {
+      tracer.traceXhr(context);
       context.requestIndex = getNextRequestIndex();
       lifeCycle.notify(_lifeCycle.LifeCycleEventType.REQUEST_STARTED, {
         requestIndex: context.requestIndex
@@ -55,6 +59,7 @@ function trackXhr(lifeCycle, configuration) {
   });
   xhrProxy.onRequestComplete(function (context) {
     if ((0, _resourceUtils.isAllowedRequestUrl)(configuration, context.url)) {
+      tracer.clearTracingIfCancelled(context);
       lifeCycle.notify(_lifeCycle.LifeCycleEventType.REQUEST_COMPLETED, {
         duration: context.duration,
         method: context.method,
@@ -63,6 +68,8 @@ function trackXhr(lifeCycle, configuration) {
         response: context.response,
         startTime: context.startTime,
         status: context.status,
+        traceId: context.traceId,
+        spanId: context.spanId,
         type: context.type,
         url: context.url
       });

package/cjs/rumEventsCollection/resource/resourceCollection.js

@@ -23,6 +23,7 @@ function processRequest(request) {
   var type = request.type;
   var timing = request.performance;
   var correspondingTimingOverrides = timing ? computePerformanceEntryMetrics(timing) : undefined;
+  var tracingInfo = computeRequestTracingInfo(request);
   var urlObj = (0, _utils.urlParse)(request.url).getParse();
   var startTime = request.startTime;
   console.log(request, 'request=========');
@@ -41,13 +42,31 @@ function processRequest(request) {
       urlQuery: (0, _utils.jsonStringify)((0, _utils.getQueryParamsFromUrl)(request.url))
     },
     type: _enums.RumEventType.RESOURCE
-  }, correspondingTimingOverrides);
+  }, tracingInfo, correspondingTimingOverrides);
   return {
     startTime: startTime,
     rawRumEvent: resourceEvent
   };
 }
 
+function computeRequestTracingInfo(request) {
+  var hasBeenTraced = request.traceId && request.spanId;
+
+  if (!hasBeenTraced) {
+    return undefined;
+  }
+
+  return {
+    _dd: {
+      spanId: request.spanId,
+      traceId: request.traceId
+    },
+    resource: {
+      id: (0, _utils.UUID)()
+    }
+  };
+}
+
 function computePerformanceEntryMetrics(timing) {
   return {
     resource: (0, _utils.extend2Lev)({}, {

package/cjs/rumEventsCollection/tracing/ddtraceTracer.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DDtraceTracer = DDtraceTracer;
+
+// === Generate a random 64-bit number in fixed-length hex format
+function randomTraceId() {
+  var digits = '0123456789abcdef';
+  var n = '';
+
+  for (var i = 0; i < 19; i += 1) {
+    var rand = Math.floor(Math.random() * 10);
+    n += digits[rand];
+  }
+
+  return n;
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ */
+
+
+function DDtraceTracer(configuration) {
+  this._spanId = randomTraceId();
+  this._traceId = randomTraceId();
+}
+
+DDtraceTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    return true;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'x-datadog-origin': 'rum',
+      // 'x-datadog-parent-id': spanId.toDecimalString(),
+      'x-datadog-sampled': '1',
+      'x-datadog-sampling-priority': '1',
+      'x-datadog-trace-id': this.getTraceId()
+    };
+  }
+};

package/cjs/rumEventsCollection/tracing/jaegerTracer.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JaegerTracer = JaegerTracer;
+
+// === Generate a random 64-bit number in fixed-length hex format
+function randomTraceId() {
+  var digits = '0123456789abcdef';
+  var n = '';
+
+  for (var i = 0; i < 16; i += 1) {
+    var rand = Math.floor(Math.random() * 16);
+    n += digits[rand];
+  }
+
+  return n;
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ */
+
+
+function JaegerTracer(configuration) {
+  var rootSpanId = randomTraceId(); // this._traceId = randomTraceId() + rootSpanId // 默认用128bit,兼容其他配置
+
+  if (configuration.traceId128Bit) {
+    // 128bit生成traceid
+    this._traceId = randomTraceId() + rootSpanId;
+  } else {
+    this._traceId = rootSpanId;
+  }
+
+  this._spanId = rootSpanId;
+}
+
+JaegerTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    return true;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  getUberTraceId: function getUberTraceId() {
+    //{trace-id}:{span-id}:{parent-span-id}:{flags}
+    return this._traceId + ':' + this._spanId + ':' + '0' + ':' + '1';
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'uber-trace-id': this.getUberTraceId()
+    };
+  }
+};

package/cjs/rumEventsCollection/tracing/skywalkingTracer.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SkyWalkingTracer = SkyWalkingTracer;
+
+var _utils = require("../../helper/utils");
+
+// start SkyWalking
+function uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    /* tslint:disable */
+    var r = Math.random() * 16 | 0;
+    /* tslint:disable */
+
+    var v = c === 'x' ? r : r & 0x3 | 0x8;
+    return v.toString(16);
+  });
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ * @param {*} requestUrl 请求的url
+ */
+
+
+function SkyWalkingTracer(configuration, requestUrl) {
+  this._spanId = uuid();
+  this._traceId = uuid();
+  this._applicationId = configuration.applicationId;
+  this._env = configuration.env;
+  this._version = configuration.version;
+  this._urlParse = (0, _utils.urlParse)(requestUrl).getParse();
+}
+
+SkyWalkingTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    if (this._env && this._version && this._urlParse) return true;
+    return false;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  getSkyWalkingSw8: function getSkyWalkingSw8() {
+    try {
+      var traceIdStr = String((0, _utils.base64Encode)(this._traceId));
+      var segmentId = String((0, _utils.base64Encode)(this._spanId));
+      var service = String((0, _utils.base64Encode)(this._applicationId + '_rum_' + this.env));
+      var instance = String((0, _utils.base64Encode)(this._version));
+      var activePage = (0, _utils.getActivePage)();
+      var endpointPage = '';
+
+      if (activePage && activePage.route) {
+        endpointPage = activePage.route;
+      }
+
+      var endpoint = String((0, _utils.base64Encode)(endpointPage));
+      var peer = String((0, _utils.base64Encode)(this._urlParse.Host));
+      var index = '0'; // var values = `${1}-${traceIdStr}-${segmentId}-${index}-${service}-${instance}-${endpoint}-${peer}`;
+
+      return '1-' + traceIdStr + '-' + segmentId + '-' + index + '-' + service + '-' + instance + '-' + endpoint + '-' + peer;
+    } catch (err) {
+      return '';
+    }
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'sw8': this.getSkyWalkingSw8()
+    };
+  }
+};

package/cjs/rumEventsCollection/tracing/tracer.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearTracingIfCancelled = clearTracingIfCancelled;
+exports.startTracer = startTracer;
+exports.injectHeadersIfTracingAllowed = injectHeadersIfTracingAllowed;
+
+var _utils = require("../../helper/utils");
+
+var _enums = require("../../helper/enums");
+
+var _ddtraceTracer = require("./ddtraceTracer");
+
+var _skywalkingTracer = require("./skywalkingTracer");
+
+var _jaegerTracer = require("./jaegerTracer");
+
+var _zipkinSingleTracer = require("./zipkinSingleTracer");
+
+var _zipkinMultiTracer = require("./zipkinMultiTracer");
+
+var _w3cTraceParentTracer = require("./w3cTraceParentTracer");
+
+function clearTracingIfCancelled(context) {
+  if (context.status === 0) {
+    context.traceId = undefined;
+    context.spanId = undefined;
+  }
+}
+
+function startTracer(configuration) {
+  return {
+    clearTracingIfCancelled: clearTracingIfCancelled,
+    traceXhr: function traceXhr(context) {
+      return injectHeadersIfTracingAllowed(configuration, context, function (tracingHeaders) {
+        context.option = (0, _utils.extend)({}, context.option);
+        var header = {};
+
+        if (context.option.header) {
+          (0, _utils.each)(context.option.header, function (value, key) {
+            header[key] = value;
+          });
+        }
+
+        context.option.header = (0, _utils.extend)(header, tracingHeaders);
+      });
+    }
+  };
+}
+
+function isAllowedUrl(configuration, requestUrl) {
+  var requestOrigin = (0, _utils.getOrigin)(requestUrl);
+  var flag = false;
+  (0, _utils.each)(configuration.allowedTracingOrigins, function (allowedOrigin) {
+    if (requestOrigin === allowedOrigin || allowedOrigin instanceof RegExp && allowedOrigin.test(requestOrigin)) {
+      flag = true;
+      return false;
+    }
+  });
+  return flag;
+}
+
+function injectHeadersIfTracingAllowed(configuration, context, inject) {
+  if (!isAllowedUrl(configuration, context.url) || !configuration.traceType) {
+    return;
+  }
+
+  var tracer;
+
+  switch (configuration.traceType) {
+    case _enums.TraceType.DDTRACE:
+      tracer = new _ddtraceTracer.DDtraceTracer();
+      break;
+
+    case _enums.TraceType.SKYWALKING_V3:
+      tracer = new _skywalkingTracer.SkyWalkingTracer(configuration, context.url);
+      break;
+
+    case _enums.TraceType.ZIPKIN_MULTI_HEADER:
+      tracer = new _zipkinMultiTracer.ZipkinMultiTracer(configuration);
+      break;
+
+    case _enums.TraceType.JAEGER:
+      tracer = new _jaegerTracer.JaegerTracer(configuration);
+      break;
+
+    case _enums.TraceType.W3C_TRACEPARENT:
+      tracer = new _w3cTraceParentTracer.W3cTraceParentTracer(configuration);
+      break;
+
+    case _enums.TraceType.ZIPKIN_SINGLE_HEADER:
+      tracer = new _zipkinSingleTracer.ZipkinSingleTracer(configuration);
+      break;
+
+    default:
+      break;
+  }
+
+  if (!tracer || !tracer.isTracingSupported()) {
+    return;
+  }
+
+  context.traceId = tracer.getTraceId();
+  context.spanId = tracer.getSpanId();
+  inject(tracer.makeTracingHeaders());
+}

package/cjs/rumEventsCollection/tracing/w3cTraceParentTracer.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.W3cTraceParentTracer = W3cTraceParentTracer;
+
+// === Generate a random 64-bit number in fixed-length hex format
+function randomTraceId() {
+  var digits = '0123456789abcdef';
+  var n = '';
+
+  for (var i = 0; i < 16; i += 1) {
+    var rand = Math.floor(Math.random() * 16);
+    n += digits[rand];
+  }
+
+  return n;
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ */
+
+
+function W3cTraceParentTracer(configuration) {
+  var rootSpanId = randomTraceId();
+  this._traceId = randomTraceId() + rootSpanId;
+  this._spanId = rootSpanId;
+}
+
+W3cTraceParentTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    return true;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  getTraceParent: function getTraceParent() {
+    // '{version}-{traceId}-{spanId}-{sampleDecision}'
+    return '00-' + this._traceId + '-' + this._spanId + '-01';
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'traceparent': this.getTraceParent()
+    };
+  }
+};

package/cjs/rumEventsCollection/tracing/zipkinMultiTracer.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZipkinMultiTracer = ZipkinMultiTracer;
+
+// === Generate a random 64-bit number in fixed-length hex format
+function randomTraceId() {
+  var digits = '0123456789abcdef';
+  var n = '';
+
+  for (var i = 0; i < 16; i += 1) {
+    var rand = Math.floor(Math.random() * 16);
+    n += digits[rand];
+  }
+
+  return n;
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ */
+
+
+function ZipkinMultiTracer(configuration) {
+  var rootSpanId = randomTraceId();
+
+  if (configuration.traceId128Bit) {
+    // 128bit生成traceid
+    this._traceId = randomTraceId() + rootSpanId;
+  } else {
+    this._traceId = rootSpanId;
+  }
+
+  this._spanId = rootSpanId;
+}
+
+ZipkinMultiTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    return true;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'X-B3-TraceId': this.getTraceId(),
+      'X-B3-SpanId': this.getSpanId(),
+      //  'X-B3-ParentSpanId': '',
+      'X-B3-Sampled': '1' //  'X-B3-Flags': '0'
+
+    };
+  }
+};

package/cjs/rumEventsCollection/tracing/zipkinSingleTracer.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZipkinSingleTracer = ZipkinSingleTracer;
+
+// === Generate a random 64-bit number in fixed-length hex format
+function randomTraceId() {
+  var digits = '0123456789abcdef';
+  var n = '';
+
+  for (var i = 0; i < 16; i += 1) {
+    var rand = Math.floor(Math.random() * 16);
+    n += digits[rand];
+  }
+
+  return n;
+}
+/**
+ * 
+ * @param {*} configuration  配置信息
+ */
+
+
+function ZipkinSingleTracer(configuration) {
+  var rootSpanId = randomTraceId();
+  this._traceId = randomTraceId() + rootSpanId;
+  this._spanId = rootSpanId;
+}
+
+ZipkinSingleTracer.prototype = {
+  isTracingSupported: function isTracingSupported() {
+    return true;
+  },
+  getSpanId: function getSpanId() {
+    return this._spanId;
+  },
+  getTraceId: function getTraceId() {
+    return this._traceId;
+  },
+  getB3Str: function getB3Str() {
+    //{TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+    return this._traceId + '-' + this._spanId + '-1';
+  },
+  makeTracingHeaders: function makeTracingHeaders() {
+    return {
+      'b3': this.getB3Str()
+    };
+  }
+};

package/esm/boot/buildEnv.js

@@ -1,4 +1,4 @@
 export var buildEnv = {
-  sdkVersion: '1.0.3',
+  sdkVersion: '2.0.1',
   sdkName: 'df_uniapp_rum_sdk'
 };

package/esm/boot/rum.entry.js

@@ -1,7 +1,17 @@
-import { isPercentage } from '../helper/utils';
+import { isPercentage, extend2Lev, createContextManager } from '../helper/utils';
 import { startRum } from './rum';
 export var makeRum = function makeRum(startRumImpl) {
   var isAlreadyInitialized = false;
+  var globalContextManager = createContextManager();
+  var user = {};
+
+  function clonedCommonContext() {
+    return extend2Lev({}, {
+      context: globalContextManager.get(),
+      user: user
+    });
+  }
+
   var rumGlobal = {
     init: function init(Vue, userConfiguration) {
       if (typeof userConfiguration === 'undefined') {
@@ -14,8 +24,29 @@ export var makeRum = function makeRum(startRumImpl) {
         return;
       }
 
-      startRumImpl(Vue, userConfiguration);
+      startRumImpl(Vue, userConfiguration, function () {
+        return {
+          user: user,
+          context: globalContextManager.get()
+        };
+      });
       isAlreadyInitialized = true;
+    },
+    addRumGlobalContext: globalContextManager.add,
+    removeRumGlobalContext: globalContextManager.remove,
+    getRumGlobalContext: globalContextManager.get,
+    setRumGlobalContext: globalContextManager.set,
+    setUser: function setUser(newUser) {
+      var sanitizedUser = sanitizeUser(newUser);
+
+      if (sanitizedUser) {
+        user = sanitizedUser;
+      } else {
+        console.error('Unsupported user:', newUser);
+      }
+    },
+    removeUser: function removeUser() {
+      user = {};
     }
   };
   return rumGlobal;
@@ -43,5 +74,27 @@ export var makeRum = function makeRum(startRumImpl) {
 
     return true;
   }
+
+  function sanitizeUser(newUser) {
+    if (typeof newUser !== 'object' || !newUser) {
+      return;
+    }
+
+    var result = extend2Lev({}, newUser);
+
+    if ('id' in result) {
+      result.id = String(result.id);
+    }
+
+    if ('name' in result) {
+      result.name = String(result.name);
+    }
+
+    if ('email' in result) {
+      result.email = String(result.email);
+    }
+
+    return result;
+  }
 };
 export var datafluxRum = makeRum(startRum);