@cloudcare/browser-logs 1.1.24 → 1.2.1

package/cjs/domain/internalContext.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startInternalContext = startInternalContext;
+
+function startInternalContext(sessionManager) {
+  return {
+    get: function get(startTime) {
+      var trackedSession = sessionManager.findTrackedSession(startTime);
+
+      if (trackedSession) {
+        return {
+          session: {
+            id: trackedSession.id
+          }
+        };
+      }
+    }
+  };
+}

package/cjs/domain/logger.js

@@ -9,31 +9,25 @@ exports.StatusType = exports.STATUSES = void 0;
 
 var _browserCore = require("@cloudcare/browser-core");
 
-var _STATUS_PRIORITIES;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 var StatusType = {
   debug: 'debug',
-  critical: 'critical',
   error: 'error',
   info: 'info',
-  warn: 'warning'
-}; // eslint-disable-next-line @typescript-eslint/no-redeclare
-
+  warn: 'warn',
+  critical: 'critical'
+};
 exports.StatusType = StatusType;
-var STATUS_PRIORITIES = (_STATUS_PRIORITIES = {}, _defineProperty(_STATUS_PRIORITIES, StatusType.debug, 0), _defineProperty(_STATUS_PRIORITIES, StatusType.info, 1), _defineProperty(_STATUS_PRIORITIES, StatusType.warn, 2), _defineProperty(_STATUS_PRIORITIES, StatusType.error, 3), _defineProperty(_STATUS_PRIORITIES, StatusType.critical, 4), _STATUS_PRIORITIES);
-var STATUSES = (0, _browserCore.keys)(StatusType);
-exports.STATUSES = STATUSES;
 var HandlerType = {
   console: 'console',
   http: 'http',
   silent: 'silent'
-}; // eslint-disable-next-line @typescript-eslint/no-redeclare
-
+};
 exports.HandlerType = HandlerType;
+var STATUSES = (0, _browserCore.keys)(StatusType); // eslint-disable-next-line @typescript-eslint/no-redeclare
+
+exports.STATUSES = STATUSES;
 
-function Logger(sendLog, handlerType, level, loggerContext) {
+function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {
   this.contextManager = (0, _browserCore.createContextManager)();
 
   if (typeof handlerType === 'undefined') {
@@ -48,10 +42,14 @@ function Logger(sendLog, handlerType, level, loggerContext) {
     loggerContext = {};
   }
 
-  this.sendLog = sendLog;
+  this.handleLogStrategy = handleLogStrategy;
   this.handlerType = handlerType;
   this.level = level;
-  this.contextManager.set(loggerContext);
+  this.contextManager.set((0, _browserCore.assign)({}, loggerContext, name ? {
+    logger: {
+      name: name
+    }
+  } : undefined));
 }
 
 Logger.prototype = {
@@ -60,26 +58,11 @@ Logger.prototype = {
       status = StatusType.info;
     }
 
-    if (STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[this.level]) {
-      switch (this.handlerType) {
-        case HandlerType.http:
-          var logMessage = (0, _browserCore.extend2Lev)({
-            message: message,
-            status: status
-          }, {
-            tags: this.contextManager.get()
-          }, messageContext);
-          this.sendLog(logMessage);
-          break;
-
-        case HandlerType.console:
-          console.log(status + ' : ' + message, (0, _browserCore.extend2Lev)(this.contextManager.get(), messageContext));
-          break;
-
-        case HandlerType.silent:
-          break;
-      }
-    }
+    this.handleLogStrategy({
+      message: message,
+      context: (0, _browserCore.deepClone)(messageContext),
+      status: status
+    }, this);
   },
   debug: function debug(message, messageContext) {
     this.log(message, messageContext, StatusType.debug);
@@ -104,6 +87,9 @@ Logger.prototype = {
   setContext: function setContext(context) {
     this.contextManager.set(context);
   },
+  getContext: function getContext() {
+    return this.contextManager.get();
+  },
   addContext: function addContext(key, value) {
     this.contextManager.add(key, value);
   },
@@ -113,7 +99,13 @@ Logger.prototype = {
   setHandler: function setHandler(handler) {
     this.handlerType = handler;
   },
+  getHandler: function getHandler() {
+    return this.handlerType;
+  },
   setLevel: function setLevel(level) {
     this.level = level;
+  },
+  getLevel: function getLevel() {
+    return this.level;
   }
 };

package/cjs/domain/logsCollection/console/consoleCollection.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startConsoleCollection = startConsoleCollection;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logger = require("../../logger");
+
+var _LogStatusForApi;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var LogStatusForApi = (_LogStatusForApi = {}, _defineProperty(_LogStatusForApi, _browserCore.ConsoleApiName.log, _logger.StatusType.info), _defineProperty(_LogStatusForApi, _browserCore.ConsoleApiName.debug, _logger.StatusType.debug), _defineProperty(_LogStatusForApi, _browserCore.ConsoleApiName.info, _logger.StatusType.info), _defineProperty(_LogStatusForApi, _browserCore.ConsoleApiName.warn, _logger.StatusType.warn), _defineProperty(_LogStatusForApi, _browserCore.ConsoleApiName.error, _logger.StatusType.error), _LogStatusForApi);
+
+function startConsoleCollection(configuration, lifeCycle) {
+  var consoleSubscription = (0, _browserCore.initConsoleObservable)(configuration.forwardConsoleLogs).subscribe(function (log) {
+    lifeCycle.notify(_browserCore.LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: (0, _browserCore.timeStampNow)(),
+        message: log.message,
+        origin: _browserCore.ErrorSource.CONSOLE,
+        error: log.api === _browserCore.ConsoleApiName.error ? {
+          origin: _browserCore.ErrorSource.CONSOLE,
+          // Todo: Remove in the next major release
+          stack: log.stack
+        } : undefined,
+        status: LogStatusForApi[log.api]
+      }
+    });
+  });
+  return {
+    stop: function stop() {
+      consoleSubscription.unsubscribe();
+    }
+  };
+}

package/cjs/domain/logsCollection/logger/loggerCollection.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STATUS_PRIORITIES = void 0;
+exports.isAuthorized = isAuthorized;
+exports.startLoggerCollection = startLoggerCollection;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logger = require("../../logger");
+
+var _STATUS_PRIORITIES;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var STATUS_PRIORITIES = (_STATUS_PRIORITIES = {}, _defineProperty(_STATUS_PRIORITIES, _logger.StatusType.debug, 0), _defineProperty(_STATUS_PRIORITIES, _logger.StatusType.info, 1), _defineProperty(_STATUS_PRIORITIES, _logger.StatusType.warn, 2), _defineProperty(_STATUS_PRIORITIES, _logger.StatusType.error, 3), _STATUS_PRIORITIES);
+exports.STATUS_PRIORITIES = STATUS_PRIORITIES;
+
+function startLoggerCollection(lifeCycle) {
+  function handleLog(logsMessage, logger, savedCommonContext, savedDate) {
+    var messageContext = logsMessage.context;
+
+    if (isAuthorized(logsMessage.status, _logger.HandlerType.console, logger)) {
+      (0, _browserCore.display)(logsMessage.status, logsMessage.message, (0, _browserCore.extend2Lev)(logger.getContext(), messageContext));
+    }
+
+    lifeCycle.notify(_browserCore.LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: savedDate || (0, _browserCore.timeStampNow)(),
+        message: logsMessage.message,
+        status: logsMessage.status,
+        origin: _browserCore.ErrorSource.LOGGER
+      },
+      messageContext: messageContext,
+      savedCommonContext: savedCommonContext,
+      logger: logger
+    });
+  }
+
+  return {
+    handleLog: handleLog
+  };
+}
+
+function isAuthorized(status, handlerType, logger) {
+  var loggerHandler = logger.getHandler();
+  var sanitizedHandlerType = (0, _browserCore.isArray)(loggerHandler) ? loggerHandler : [loggerHandler];
+  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && (0, _browserCore.includes)(sanitizedHandlerType, handlerType);
+}

package/cjs/domain/logsCollection/networkError/networkErrorCollection.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeFetchErrorText = computeFetchErrorText;
+exports.computeFetchResponseText = computeFetchResponseText;
+exports.computeXhrResponseData = computeXhrResponseData;
+exports.startNetworkErrorCollection = startNetworkErrorCollection;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logger = require("../../logger");
+
+function startNetworkErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return {
+      stop: _browserCore.noop
+    };
+  }
+
+  var xhrSubscription = (0, _browserCore.initXhrObservable)().subscribe(function (context) {
+    if (context.state === 'complete') {
+      handleCompleteRequest(_browserCore.RequestType.XHR, context, configuration);
+    }
+  });
+  var fetchSubscription = (0, _browserCore.initFetchObservable)().subscribe(function (context) {
+    if (context.state === 'complete') {
+      handleCompleteRequest(_browserCore.RequestType.FETCH, context, configuration);
+    }
+  });
+
+  function handleCompleteRequest(type, request) {
+    if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request) || configuration.isServerError(request))) {
+      if ('xhr' in request) {
+        computeXhrResponseData(request.xhr, configuration, onResponseDataAvailable);
+      } else if (request.response) {
+        computeFetchResponseText(request.response, configuration, onResponseDataAvailable);
+      } else if (request.error) {
+        computeFetchErrorText(request.error, configuration, onResponseDataAvailable);
+      }
+    }
+
+    function onResponseDataAvailable(responseData) {
+      var urlObj = (0, _browserCore.urlParse)(request.url).getParse();
+      lifeCycle.notify(_browserCore.LifeCycleEventType.RAW_LOG_COLLECTED, {
+        rawLogsEvent: {
+          message: format(type) + ' error ' + request.method + ' ' + request.url,
+          date: request.startClocks.timeStamp,
+          error: {
+            origin: _browserCore.ErrorSource.NETWORK,
+            // Todo: Remove in the next major release
+            stack: responseData || 'Failed to load'
+          },
+          http: {
+            method: request.method,
+            // Cast resource method because of case mismatch cf issue RUMF-1152
+            status_code: request.status,
+            url: request.url,
+            statusGroup: (0, _browserCore.getStatusGroup)(request.status),
+            urlHost: urlObj.Host,
+            urlPath: urlObj.Path,
+            urlPathGroup: (0, _browserCore.replaceNumberCharByPath)(urlObj.Path)
+          },
+          status: _logger.StatusType.error,
+          origin: _browserCore.ErrorSource.NETWORK
+        }
+      });
+    }
+  }
+
+  return {
+    stop: function stop() {
+      xhrSubscription.unsubscribe();
+      fetchSubscription.unsubscribe();
+    }
+  };
+} // TODO: ideally, computeXhrResponseData should always call the callback with a string instead of
+// `unknown`. But to keep backward compatibility, in the case of XHR with a `responseType` different
+// than "text", the response data should be whatever `xhr.response` is. This is a bit confusing as
+// Logs event 'stack' is expected to be a string. This should be changed in a future major version
+// as it could be a breaking change.
+
+
+function computeXhrResponseData(xhr, configuration, callback) {
+  if (typeof xhr.response === 'string') {
+    callback(truncateResponseText(xhr.response, configuration));
+  } else {
+    callback(xhr.response);
+  }
+}
+
+function computeFetchErrorText(error, configuration, callback) {
+  callback(truncateResponseText((0, _browserCore.toStackTraceString)((0, _browserCore.computeStackTrace)(error)), configuration));
+}
+
+function computeFetchResponseText(response, configuration, callback) {
+  if (!window.TextDecoder) {
+    // If the browser doesn't support TextDecoder, let's read the whole response then truncate it.
+    //
+    // This should only be the case on early versions of Edge (before they migrated to Chromium).
+    // Even if it could be possible to implement a workaround for the missing TextDecoder API (using
+    // a Blob and FileReader), we found another issue preventing us from reading only the first
+    // bytes from the response: contrary to other browsers, when reading from the cloned response,
+    // if the original response gets canceled, the cloned response is also canceled and we can't
+    // know about it.  In the following illustration, the promise returned by `reader.read()` may
+    // never be fulfilled:
+    //
+    // fetch('/').then((response) => {
+    //   const reader = response.clone().body.getReader()
+    //   readMore()
+    //   function readMore() {
+    //     reader.read().then(
+    //       (result) => {
+    //         if (result.done) {
+    //           console.log('done')
+    //         } else {
+    //           readMore()
+    //         }
+    //       },
+    //       () => console.log('error')
+    //     )
+    //   }
+    //   response.body.getReader().cancel()
+    // })
+    response.clone().text().then(function (text) {
+      return callback(truncateResponseText(text, configuration));
+    }, function (error) {
+      return callback('Unable to retrieve response: ' + error);
+    });
+  } else if (!response.body) {
+    callback();
+  } else {
+    truncateResponseStream(response.clone().body, configuration.requestErrorResponseLengthLimit, function (error, responseText) {
+      if (error) {
+        callback('Unable to retrieve response: ' + error);
+      } else {
+        callback(responseText);
+      }
+    });
+  }
+}
+
+function isRejected(request) {
+  return request.status === 0 && request.responseType !== 'opaque';
+}
+
+function isServerError(request) {
+  return request.status >= 500;
+}
+
+function truncateResponseText(responseText, configuration) {
+  if (responseText.length > configuration.requestErrorResponseLengthLimit) {
+    return responseText.substring(0, configuration.requestErrorResponseLengthLimit) + '...';
+  }
+
+  return responseText;
+}
+
+function format(type) {
+  if (_browserCore.RequestType.XHR === type) {
+    return 'XHR';
+  }
+
+  return 'Fetch';
+}
+
+function truncateResponseStream(stream, limit, callback) {
+  readLimitedAmountOfBytes(stream, limit, function (error, bytes, limitExceeded) {
+    if (error) {
+      callback(error);
+    } else {
+      var responseText = new TextDecoder().decode(bytes);
+
+      if (limitExceeded) {
+        responseText += '...';
+      }
+
+      callback(undefined, responseText);
+    }
+  });
+}
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+
+
+function readLimitedAmountOfBytes(stream, limit, callback) {
+  var reader = stream.getReader();
+  var chunks = [];
+  var readBytesCount = 0;
+  readMore();
+
+  function readMore() {
+    reader.read().then(function (result) {
+      if (result.done) {
+        onDone();
+        return;
+      }
+
+      chunks.push(result.value);
+      readBytesCount += result.value.length;
+
+      if (readBytesCount > limit) {
+        onDone();
+      } else {
+        readMore();
+      }
+    }, function (error) {
+      return callback(error);
+    });
+  }
+
+  function onDone() {
+    reader.cancel()["catch"]( // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+    // as an unhandled rejection
+    _browserCore.noop);
+    var completeBuffer;
+
+    if (chunks.length === 1) {
+      // optim: if the response is small enough to fit in a single buffer (provided by the browser), just
+      // use it directly.
+      completeBuffer = chunks[0];
+    } else {
+      // else, we need to copy buffers into a larger buffer to concatenate them.
+      completeBuffer = new Uint8Array(readBytesCount);
+      var offset = 0;
+      (0, _browserCore.each)(chunks, function (chunk) {
+        completeBuffer.set(chunk, offset);
+        offset += chunk.length;
+      });
+    }
+
+    callback(undefined, completeBuffer.slice(0, limit), completeBuffer.length > limit);
+  }
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startReportCollection = startReportCollection;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logger = require("../../logger");
+
+var _LogStatusForReport;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var LogStatusForReport = (_LogStatusForReport = {}, _defineProperty(_LogStatusForReport, _browserCore.RawReportType.cspViolation, _logger.StatusType.error), _defineProperty(_LogStatusForReport, _browserCore.RawReportType.intervention, _logger.StatusType.error), _defineProperty(_LogStatusForReport, _browserCore.RawReportType.deprecation, _logger.StatusType.warn), _LogStatusForReport);
+
+function startReportCollection(configuration, lifeCycle) {
+  var reportSubscription = (0, _browserCore.initReportObservable)(configuration.forwardReports).subscribe(function (report) {
+    var message = report.message;
+    var status = LogStatusForReport[report.type];
+    var error;
+
+    if (status === _logger.StatusType.error) {
+      error = {
+        kind: report.subtype,
+        origin: _browserCore.ErrorSource.REPORT,
+        // Todo: Remove in the next major release
+        stack: report.stack
+      };
+    } else if (report.stack) {
+      message += ' Found in ' + (0, _browserCore.getFileFromStackTraceString)(report.stack);
+    }
+
+    lifeCycle.notify(_browserCore.LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: (0, _browserCore.timeStampNow)(),
+        message: message,
+        origin: _browserCore.ErrorSource.REPORT,
+        error: error,
+        status: status
+      }
+    });
+  });
+  return {
+    stop: function stop() {
+      reportSubscription.unsubscribe();
+    }
+  };
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startRuntimeErrorCollection = startRuntimeErrorCollection;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logger = require("../../logger");
+
+function startRuntimeErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return {
+      stop: _browserCore.noop
+    };
+  }
+
+  var rawErrorObservable = new _browserCore.Observable();
+
+  var _trackRuntimeError = (0, _browserCore.trackRuntimeError)(rawErrorObservable);
+
+  var rawErrorSubscription = rawErrorObservable.subscribe(function (rawError) {
+    lifeCycle.notify(_browserCore.LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: rawError.message,
+        date: rawError.startClocks.timeStamp,
+        error: {
+          kind: rawError.type,
+          origin: _browserCore.ErrorSource.SOURCE,
+          // Todo: Remove in the next major release
+          stack: rawError.stack
+        },
+        origin: _browserCore.ErrorSource.SOURCE,
+        status: _logger.StatusType.error
+      }
+    });
+  });
+  return {
+    stop: function stop() {
+      _trackRuntimeError.stop();
+
+      rawErrorSubscription.unsubscribe();
+    }
+  };
+}

package/cjs/domain/{loggerSession.js → logsSessionManager.js}

@@ -3,43 +3,39 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.LoggerTrackingType = exports.LOGGER_SESSION_KEY = void 0;
-exports.startLoggerSession = startLoggerSession;
+exports.LoggerTrackingType = exports.LOGS_SESSION_KEY = void 0;
+exports.startLogsSessionManager = startLogsSessionManager;
 
 var _browserCore = require("@cloudcare/browser-core");
 
-var LOGGER_SESSION_KEY = 'logs';
-exports.LOGGER_SESSION_KEY = LOGGER_SESSION_KEY;
+var LOGS_SESSION_KEY = 'logs';
+exports.LOGS_SESSION_KEY = LOGS_SESSION_KEY;
 var LoggerTrackingType = {
   NOT_TRACKED: '0',
   TRACKED: '1'
 };
 exports.LoggerTrackingType = LoggerTrackingType;
 
-function startLoggerSession(configuration, areCookieAuthorized) {
-  if (!areCookieAuthorized) {
-    var _isTracked = computeTrackingType(configuration) === LoggerTrackingType.TRACKED;
-
-    return {
-      getId: function getId() {
-        return undefined;
-      },
-      isTracked: function isTracked() {
-        return _isTracked;
-      }
-    };
-  }
-
-  var session = (0, _browserCore.startSessionManagement)(configuration.cookieOptions, LOGGER_SESSION_KEY, function (rawTrackingType) {
+function startLogsSessionManager(configuration) {
+  var sessionManager = (0, _browserCore.startSessionManager)(configuration.cookieOptions, LOGS_SESSION_KEY, function (rawTrackingType) {
     return computeSessionState(configuration, rawTrackingType);
   });
   return {
-    getId: session.getId,
-    isTracked: function isTracked() {
-      return session.getTrackingType() === LoggerTrackingType.TRACKED;
+    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 (!(0, _browserCore.performDraw)(configuration.sampleRate)) {

package/cjs/entries/main.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.datafluxLogs = void 0;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+var _logsPublicApi = require("../boot/logsPublicApi");
+
+var _startLogs = require("../boot/startLogs");
+
+var datafluxLogs = (0, _logsPublicApi.makeLogsPublicApi)(_startLogs.startLogs);
+exports.datafluxLogs = datafluxLogs;
+(0, _browserCore.defineGlobal)((0, _browserCore.getGlobalObject)(), 'DATAFLUX_LOGS', datafluxLogs);

package/cjs/index.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 Object.defineProperty(exports, "datafluxLogs", {
   enumerable: true,
   get: function get() {
-    return _log.datafluxLogs;
+    return _main.datafluxLogs;
   }
 });
 
-var _log = require("./boot/log.entry");
+var _main = require("./entries/main");

package/cjs/transport/startLogsBatch.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startLogsBatch = startLogsBatch;
+
+var _browserCore = require("@cloudcare/browser-core");
+
+function startLogsBatch(configuration, lifeCycle, reportError) {
+  var batch = (0, _browserCore.startBatchWithReplica)(configuration, configuration.logsEndpoint, reportError);
+  lifeCycle.subscribe(_browserCore.LifeCycleEventType.LOG_COLLECTED, function (serverLogsEvent) {
+    batch.add(serverLogsEvent);
+  });
+}

package/esm/boot/buildEnv.js

@@ -1,4 +1,4 @@
 export var buildEnv = {
-  sdkVersion: '1.1.24',
+  sdkVersion: '1.2.1',
   sdkName: 'df_web_logs_sdk'
 };