@cloudcare/rum-uniapp 2.1.17 → 2.1.20

package/esm/rumEventsCollection/resource/resourceUtils.js

@@ -1,24 +1,22 @@
 import { msToNs, toArray, extend } from '../../helper/utils';
 import { isIntakeRequest } from '../../core/configuration';
-
 function areInOrder() {
   var numbers = toArray(arguments);
-
   for (var i = 1; i < numbers.length; i += 1) {
     if (numbers[i - 1] > numbers[i]) {
       return false;
     }
   }
-
   return true;
 }
-
 export function computePerformanceResourceDuration(entry) {
   // Safari duration is always 0 on timings blocked by cross origin policies.
   if (entry.startTime < entry.responseEnd) {
     return msToNs(entry.responseEnd - entry.startTime);
   }
-} //  interface PerformanceResourceDetails {
+}
+
+//  interface PerformanceResourceDetails {
 //   redirect?: PerformanceResourceDetailsElement
 //   dns?: PerformanceResourceDetailsElement
 //   connect?: PerformanceResourceDetailsElement
@@ -40,71 +38,88 @@ export function computePerformanceResourceDuration(entry) {
 // page_trans	float		内容传输时间	responseEnd - responseStart
 // page_dom	float		DOM解析耗时	domInteractive - responseEnd
 // page_resource_load_time	float		资源加载时间	loadEventStart - domContentLoadedEventEnd
+
 //  navigationStart：当前浏览器窗口的前一个网页关闭，发生unload事件时的Unix毫秒时间戳。如果没有前一个网页，则等于fetchStart属性。
+
 // ·   unloadEventStart：如果前一个网页与当前网页属于同一个域名，则返回前一个网页的unload事件发生时的Unix毫秒时间戳。如果没有前一个网页，或者之前的网页跳转不是在同一个域名内，则返回值为0。
+
 // ·   unloadEventEnd：如果前一个网页与当前网页属于同一个域名，则返回前一个网页unload事件的回调函数结束时的Unix毫秒时间戳。如果没有前一个网页，或者之前的网页跳转不是在同一个域名内，则返回值为0。
+
 // ·   redirectStart：返回第一个HTTP跳转开始时的Unix毫秒时间戳。如果没有跳转，或者不是同一个域名内部的跳转，则返回值为0。
+
 // ·   redirectEnd：返回最后一个HTTP跳转结束时（即跳转回应的最后一个字节接受完成时）的Unix毫秒时间戳。如果没有跳转，或者不是同一个域名内部的跳转，则返回值为0。
+
 // ·   fetchStart：返回浏览器准备使用HTTP请求读取文档时的Unix毫秒时间戳。该事件在网页查询本地缓存之前发生。
+
 // ·   domainLookupStart：返回域名查询开始时的Unix毫秒时间戳。如果使用持久连接，或者信息是从本地缓存获取的，则返回值等同于fetchStart属性的值。
+
 // ·   domainLookupEnd：返回域名查询结束时的Unix毫秒时间戳。如果使用持久连接，或者信息是从本地缓存获取的，则返回值等同于fetchStart属性的值。
+
 // ·   connectStart：返回HTTP请求开始向服务器发送时的Unix毫秒时间戳。如果使用持久连接（persistent connection），则返回值等同于fetchStart属性的值。
+
 // ·   connectEnd：返回浏览器与服务器之间的连接建立时的Unix毫秒时间戳。如果建立的是持久连接，则返回值等同于fetchStart属性的值。连接建立指的是所有握手和认证过程全部结束。
+
 // ·   secureConnectionStart：返回浏览器与服务器开始安全链接的握手时的Unix毫秒时间戳。如果当前网页不要求安全连接，则返回0。
+
 // ·   requestStart：返回浏览器向服务器发出HTTP请求时（或开始读取本地缓存时）的Unix毫秒时间戳。
+
 // ·   responseStart：返回浏览器从服务器收到（或从本地缓存读取）第一个字节时的Unix毫秒时间戳。
+
 // ·   responseEnd：返回浏览器从服务器收到（或从本地缓存读取）最后一个字节时（如果在此之前HTTP连接已经关闭，则返回关闭时）的Unix毫秒时间戳。
+
 // ·   domLoading：返回当前网页DOM结构开始解析时（即Document.readyState属性变为“loading”、相应的readystatechange事件触发时）的Unix毫秒时间戳。
+
 // ·   domInteractive：返回当前网页DOM结构结束解析、开始加载内嵌资源时（即Document.readyState属性变为“interactive”、相应的readystatechange事件触发时）的Unix毫秒时间戳。
+
 // ·   domContentLoadedEventStart：返回当前网页DOMContentLoaded事件发生时（即DOM结构解析完毕、所有脚本开始运行时）的Unix毫秒时间戳。
+
 // ·   domContentLoadedEventEnd：返回当前网页所有需要执行的脚本执行完成时的Unix毫秒时间戳。
+
 // ·   domComplete：返回当前网页DOM结构生成时（即Document.readyState属性变为“complete”，以及相应的readystatechange事件发生时）的Unix毫秒时间戳。
+
 // ·   loadEventStart：返回当前网页load事件的回调函数开始时的Unix毫秒时间戳。如果该事件还没有发生，返回0。
-// ·   loadEventEnd：返回当前网页load事件的回调函数运行结束时的Unix毫秒时间戳。如果该事件还没有发生，返回0
 
+// ·   loadEventEnd：返回当前网页load事件的回调函数运行结束时的Unix毫秒时间戳。如果该事件还没有发生，返回0
 export function computePerformanceResourceDetails(entry) {
   var validEntry = toValidEntry(entry);
-
   if (!validEntry) {
     return undefined;
   }
-
   var startTime = validEntry.startTime,
-      fetchStart = validEntry.fetchStart,
-      redirectStart = validEntry.redirectStart,
-      redirectEnd = validEntry.redirectEnd,
-      domainLookupStart = validEntry.domainLookupStart || validEntry.domainLookUpStart,
-      domainLookupEnd = validEntry.domainLookupEnd || validEntry.domainLookUpEnd,
-      connectStart = validEntry.connectStart,
-      SSLconnectionStart = validEntry.SSLconnectionStart,
-      SSLconnectionEnd = validEntry.SSLconnectionEnd,
-      connectEnd = validEntry.connectEnd,
-      requestStart = validEntry.requestStart,
-      responseStart = validEntry.responseStart,
-      responseEnd = validEntry.responseEnd;
+    fetchStart = validEntry.fetchStart,
+    redirectStart = validEntry.redirectStart,
+    redirectEnd = validEntry.redirectEnd,
+    domainLookupStart = validEntry.domainLookupStart || validEntry.domainLookUpStart,
+    domainLookupEnd = validEntry.domainLookupEnd || validEntry.domainLookUpEnd,
+    connectStart = validEntry.connectStart,
+    SSLconnectionStart = validEntry.SSLconnectionStart,
+    SSLconnectionEnd = validEntry.SSLconnectionEnd,
+    connectEnd = validEntry.connectEnd,
+    requestStart = validEntry.requestStart,
+    responseStart = validEntry.responseStart,
+    responseEnd = validEntry.responseEnd;
   var details = {
     firstbyte: formatTiming(startTime, domainLookupStart, responseStart),
     trans: formatTiming(startTime, responseStart, responseEnd),
     ttfb: formatTiming(startTime, requestStart, responseStart)
-  }; // Make sure a connection occurred
-
+  };
+  // Make sure a connection occurred
   if (connectEnd !== fetchStart) {
-    details.tcp = formatTiming(startTime, connectStart, connectEnd); // Make sure a secure connection occurred
+    details.tcp = formatTiming(startTime, connectStart, connectEnd);
 
+    // Make sure a secure connection occurred
     if (areInOrder(connectStart, SSLconnectionStart, SSLconnectionEnd)) {
       details.ssl = formatTiming(startTime, SSLconnectionStart, SSLconnectionEnd);
     }
-  } // Make sure a domain lookup occurred
-
+  }
 
+  // Make sure a domain lookup occurred
   if (domainLookupEnd !== fetchStart) {
     details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);
   }
-
   if (hasRedirection(entry)) {
     details.redirect = formatTiming(startTime, redirectStart, redirectEnd);
   }
-
   return details;
 }
 export function toValidEntry(entry) {
@@ -128,32 +143,29 @@ export function toValidEntry(entry) {
   if (!areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd)) {
     return undefined;
   }
-
   if (!hasRedirection(entry)) {
     return entry;
   }
-
   var redirectStart = entry.redirectStart;
-  var redirectEnd = entry.redirectEnd; // Firefox doesn't provide redirect timings on cross origin requests.
+  var redirectEnd = entry.redirectEnd;
+  // Firefox doesn't provide redirect timings on cross origin requests.
   // Provide a default for those.
-
   if (redirectStart < entry.startTime) {
     redirectStart = entry.startTime;
   }
-
   if (redirectEnd < entry.startTime) {
     redirectEnd = entry.fetchStart;
-  } // Make sure redirect timings are in order
-
+  }
 
+  // Make sure redirect timings are in order
   if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {
     return undefined;
   }
-
   return extend({}, entry, {
     redirectEnd: redirectEnd,
     redirectStart: redirectStart
-  }); // return {
+  });
+  // return {
   //   ...entry,
   //   redirectEnd,
   //   redirectStart
@@ -164,17 +176,14 @@ function hasRedirection(entry) {
   // The only time fetchStart is different than startTime is if a redirection occurred.
   return entry.fetchStart !== entry.startTime;
 }
-
 function formatTiming(origin, start, end) {
   return msToNs(end - start);
 }
-
 export function computeSize(entry) {
   // Make sure a request actually occurred
   if (entry.startTime < entry.responseStart) {
     return entry.receivedBytedCount;
   }
-
   return undefined;
 }
 export function isAllowedRequestUrl(configuration, url) {

package/esm/rumEventsCollection/setDataCollection.js

@@ -1,31 +1,24 @@
 import { LifeCycleEventType } from '../core/lifeCycle';
 import { now } from '../helper/utils';
 import { tracker } from '../core/sdk';
-
 function resetSetData(data, callback, lifeCycle, mpInstance) {
   var pendingStartTimestamp = now();
-
   var _callback = function _callback() {
     lifeCycle.notify(LifeCycleEventType.PAGE_SET_DATA_UPDATE, {
       pendingStartTimestamp: pendingStartTimestamp,
       updateEndTimestamp: now()
     });
-
     if (typeof callback === 'function') {
       callback.call(mpInstance);
     }
   };
-
   return _callback;
 }
-
 function proxyPage(pageOptions, lifeCycle) {
   var userDefinedMethod = pageOptions['onLoad'];
-
   pageOptions['onLoad'] = function () {
     var mpInstance = this.$scope;
     var setData = mpInstance.setData;
-
     if (typeof setData === 'function') {
       try {
         // 这里暂时这么处理 只读属性 会抛出错误
@@ -42,15 +35,12 @@ function proxyPage(pageOptions, lifeCycle) {
         });
       }
     }
-
     return userDefinedMethod && userDefinedMethod.apply(this, arguments);
   };
 }
-
 export function startSetDataColloction(lifeCycle, Vue) {
   if (Vue && Vue.extend) {
     var originVueExtend = Vue.extend;
-
     Vue.extend = function (vueOptions) {
       proxyPage(vueOptions, lifeCycle);
       return originVueExtend.call(this, vueOptions);
@@ -58,14 +48,11 @@ export function startSetDataColloction(lifeCycle, Vue) {
   } else {
     if (!tracker) return;
     var originCreatePage = tracker.createPage;
-
     tracker.createPage = function (pageOptions) {
       proxyPage(pageOptions, lifeCycle);
       return originCreatePage.call(this, pageOptions);
     };
-
     var originCreateComponent = tracker.createComponent;
-
     tracker.createComponent = function (component) {
       proxyPage(component, lifeCycle);
       return originCreateComponent.call(this, component);

package/esm/rumEventsCollection/tracing/ddtraceTracer.js

@@ -2,20 +2,16 @@
 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  配置信息
  */
-
-
 export function DDtraceTracer(configuration) {
   this._spanId = randomTraceId();
   this._traceId = randomTraceId();

package/esm/rumEventsCollection/tracing/jaegerTracer.js

@@ -2,30 +2,26 @@
 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 JaegerTracer(configuration) {
-  var rootSpanId = randomTraceId(); // this._traceId = randomTraceId() + rootSpanId // 默认用128bit,兼容其他配置
-
+  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 = {

package/esm/rumEventsCollection/tracing/skywalkingTracer.js

@@ -1,22 +1,20 @@
-import { base64Encode, urlParse, getActivePage } from '../../helper/utils'; // start SkyWalking
-
+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();
@@ -44,15 +42,13 @@ SkyWalkingTracer.prototype = {
       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}`;
-
+      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 '';

package/esm/rumEventsCollection/tracing/tracer.js

@@ -19,19 +19,16 @@ export function startTracer(configuration) {
       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;
@@ -43,47 +40,36 @@ function isAllowedUrl(configuration, requestUrl) {
   });
   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

@@ -2,20 +2,17 @@
 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;

package/esm/rumEventsCollection/tracing/zipkinMultiTracer.js

@@ -2,30 +2,25 @@
 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 = {
@@ -43,8 +38,8 @@ ZipkinMultiTracer.prototype = {
       'X-B3-TraceId': this.getTraceId(),
       'X-B3-SpanId': this.getSpanId(),
       //  'X-B3-ParentSpanId': '',
-      'X-B3-Sampled': '1' //  'X-B3-Flags': '0'
-
+      'X-B3-Sampled': '1'
+      //  'X-B3-Flags': '0'
     };
   }
 };

package/esm/rumEventsCollection/tracing/zipkinSingleTracer.js

@@ -2,20 +2,17 @@
 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;

package/esm/rumEventsCollection/trackEventCounts.js

@@ -5,7 +5,6 @@ export function trackEventCounts(lifeCycle, callback) {
   if (typeof callback === 'undefined') {
     callback = noop;
   }
-
   var eventCounts = {
     errorCount: 0,
     resourceCount: 0,
@@ -14,18 +13,15 @@ export function trackEventCounts(lifeCycle, callback) {
   };
   var subscription = lifeCycle.subscribe(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, function (data) {
     var rawRumEvent = data.rawRumEvent;
-
     switch (rawRumEvent.type) {
       case RumEventType.ERROR:
         eventCounts.errorCount += 1;
         callback(eventCounts);
         break;
-
       case RumEventType.RESOURCE:
         eventCounts.resourceCount += 1;
         callback(eventCounts);
         break;
-
       case RumEventType.ACTION:
         eventCounts.userActionCount += 1;
         callback(eventCounts);

package/esm/rumEventsCollection/trackPageActiveites.js

@@ -1,31 +1,28 @@
 import { each, now } from '../helper/utils';
 import { LifeCycleEventType } from '../core/lifeCycle';
-import { Observable } from '../core/observable'; // Delay to wait for a page activity to validate the tracking process
-
-export var PAGE_ACTIVITY_VALIDATION_DELAY = 100; // Delay to wait after a page activity to end the tracking process
-
-export var PAGE_ACTIVITY_END_DELAY = 100; // Maximum duration of the tracking process
-
+import { Observable } from '../core/observable';
+// Delay to wait for a page activity to validate the tracking process
+export var PAGE_ACTIVITY_VALIDATION_DELAY = 100;
+// Delay to wait after a page activity to end the tracking process
+export var PAGE_ACTIVITY_END_DELAY = 100;
+// Maximum duration of the tracking process
 export var PAGE_ACTIVITY_MAX_DURATION = 10000;
 export function waitIdlePageActivity(lifeCycle, completionCallback) {
   var _trackPageActivities = trackPageActivities(lifeCycle);
-
   var pageActivitiesObservable = _trackPageActivities.observable;
   var stopPageActivitiesTracking = _trackPageActivities.stop;
-
   var _waitPageActivitiesCompletion = waitPageActivitiesCompletion(pageActivitiesObservable, stopPageActivitiesTracking, completionCallback);
-
   var stopWaitPageActivitiesCompletion = _waitPageActivitiesCompletion.stop;
-
   function stop() {
     stopWaitPageActivitiesCompletion();
     stopPageActivitiesTracking();
   }
-
   return {
     stop: stop
   };
-} // Automatic action collection lifecycle overview:
+}
+
+// Automatic action collection lifecycle overview:
 //                      (Start new trackPageActivities)
 //              .-------------------'--------------------.
 //              v                                        v
@@ -49,7 +46,6 @@ export function waitIdlePageActivity(lifeCycle, completionCallback) {
 //
 // Note: because MAX_DURATION > VALIDATION_DELAY, we are sure that if the process is still alive
 // after MAX_DURATION, it has been validated.
-
 export function trackPageActivities(lifeCycle) {
   var observable = new Observable();
   var subscriptions = [];
@@ -64,7 +60,6 @@ export function trackPageActivities(lifeCycle) {
     if (firstRequestIndex === undefined) {
       firstRequestIndex = startEvent.requestIndex;
     }
-
     pendingRequestsCount += 1;
     notifyPageActivity();
   }));
@@ -73,17 +68,14 @@ export function trackPageActivities(lifeCycle) {
     if (firstRequestIndex === undefined || request.requestIndex < firstRequestIndex) {
       return;
     }
-
     pendingRequestsCount -= 1;
     notifyPageActivity();
   }));
-
   function notifyPageActivity() {
     observable.notify({
       isBusy: pendingRequestsCount > 0
     });
   }
-
   return {
     observable: observable,
     stop: function stop() {
@@ -112,7 +104,6 @@ export function waitPageActivitiesCompletion(pageActivitiesObservable, stopPageA
     clearTimeout(validationTimeoutId);
     clearTimeout(idleTimeoutId);
     var lastChangeTime = now();
-
     if (!isBusy) {
       idleTimeoutId = setTimeout(function () {
         complete({
@@ -122,7 +113,6 @@ export function waitPageActivitiesCompletion(pageActivitiesObservable, stopPageA
       }, PAGE_ACTIVITY_END_DELAY);
     }
   });
-
   function stop() {
     hasCompleted = true;
     clearTimeout(validationTimeoutId);
@@ -130,16 +120,13 @@ export function waitPageActivitiesCompletion(pageActivitiesObservable, stopPageA
     clearTimeout(maxDurationTimeoutId);
     stopPageActivitiesTracking();
   }
-
   function complete(params) {
     if (hasCompleted) {
       return;
     }
-
     stop();
     completionCallback(params);
   }
-
   return {
     stop: stop
   };

package/esm/rumEventsCollection/transport/batch.js

@@ -16,21 +16,17 @@ export function startRumBatch(configuration, lifeCycle) {
     }
   };
 }
-
 function makeRumBatch(configuration, lifeCycle) {
   var primaryBatch = createRumBatch(configuration.datakitUrl, lifeCycle);
-
   function createRumBatch(endpointUrl, lifeCycle) {
     return new Batch(new HttpRequest(endpointUrl, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout, lifeCycle);
   }
-
   var stopped = false;
   return {
     add: function add(message) {
       if (stopped) {
         return;
       }
-
       primaryBatch.add(message);
     },
     stop: function stop() {
@@ -40,7 +36,6 @@ function makeRumBatch(configuration, lifeCycle) {
       if (stopped) {
         return;
       }
-
       primaryBatch.upsert(message, key);
     }
   };