@cloudcare/rum-uniapp 1.0.2 → 2.0.2

package/esm/rumEventsCollection/tracing/skywalkingTracer.js

@@ -0,0 +1,66 @@
+import { base64Encode, urlParse, getActivePage } from '../../helper/utils'; // start SkyWalking
+
+function uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, 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
+ */
+
+
+export function SkyWalkingTracer(configuration, requestUrl) {
+  this._spanId = uuid();
+  this._traceId = uuid();
+  this._applicationId = configuration.applicationId;
+  this._env = configuration.env;
+  this._version = configuration.version;
+  this._urlParse = 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(base64Encode(this._traceId));
+      var segmentId = String(base64Encode(this._spanId));
+      var service = String(base64Encode(this._applicationId + '_rum_' + this.env));
+      var instance = String(base64Encode(this._version));
+      var activePage = getActivePage();
+      var endpointPage = '';
+
+      if (activePage && activePage.route) {
+        endpointPage = activePage.route;
+      }
+
+      var endpoint = String(base64Encode(endpointPage));
+      var peer = String(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/esm/rumEventsCollection/tracing/tracer.js

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

package/esm/rumEventsCollection/tracing/w3cTraceParentTracer.js

@@ -0,0 +1,43 @@
+// === 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  配置信息
+ */
+
+
+export 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/esm/rumEventsCollection/tracing/zipkinMultiTracer.js

@@ -0,0 +1,50 @@
+// === 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  配置信息
+ */
+
+
+export 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/esm/rumEventsCollection/tracing/zipkinSingleTracer.js

@@ -0,0 +1,43 @@
+// === 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  配置信息
+ */
+
+
+export 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cloudcare/rum-uniapp",
-	"version": "1.0.2",
+	"version": "2.0.2",
 	"main": "cjs/index.js",
 	"module": "esm/index.js",
 	"miniprogram": "cjs",
@@ -35,6 +35,10 @@
 	],
 	"author": "dataflux",
 	"license": "MIT",
+	"repository": {
+		"url": "https://github.com/DataFlux-cn/datakit-miniprogram-uniapp",
+		"type": "git"
+	},
 	"description": "DataFlux RUM 小程序 端数据指标监控",
 	"dependencies": {}
 }