@cloudcare/browser-logs 1.1.23 → 1.2.0

package/esm/boot/logsPublicApi.js

@@ -0,0 +1,122 @@
+import { BoundedBuffer, createContextManager, makePublicApi, display, deepClone, timeStampNow } from '@cloudcare/browser-core';
+import { validateAndBuildLogsConfiguration } from '../domain/configuration';
+import { Logger } from '../domain/logger';
+export function makeLogsPublicApi(startLogsImpl) {
+  var isAlreadyInitialized = false;
+  var globalContextManager = createContextManager();
+  var customLoggers = {};
+
+  var getInternalContextStrategy = function getInternalContextStrategy() {
+    return undefined;
+  };
+
+  var beforeInitLoggerLog = new BoundedBuffer();
+
+  var _handleLogStrategy = function handleLogStrategy(logsMessage, logger, savedCommonContext, date) {
+    if (typeof savedCommonContext === 'undefined') {
+      savedCommonContext = deepClone(getCommonContext());
+    }
+
+    if (typeof date === 'undefined') {
+      date = timeStampNow();
+    }
+
+    beforeInitLoggerLog.add(function () {
+      return _handleLogStrategy(logsMessage, logger, savedCommonContext, date);
+    });
+  };
+
+  var getInitConfigurationStrategy = function getInitConfigurationStrategy() {
+    return undefined;
+  };
+
+  var mainLogger = new Logger(function () {
+    return _handleLogStrategy.apply(this, arguments);
+  });
+
+  function getCommonContext() {
+    return {
+      view: {
+        referrer: document.referrer,
+        url: window.location.href
+      },
+      context: globalContextManager.get()
+    };
+  }
+
+  return makePublicApi({
+    logger: mainLogger,
+    init: function init(initConfiguration) {
+      if (!canInitLogs(initConfiguration)) {
+        return;
+      }
+
+      var configuration = validateAndBuildLogsConfiguration(initConfiguration);
+
+      if (!configuration) {
+        return;
+      }
+
+      var _startLogsImpl = startLogsImpl(configuration, getCommonContext, mainLogger);
+
+      _handleLogStrategy = _startLogsImpl.handleLog;
+      getInternalContextStrategy = _startLogsImpl.getInternalContext;
+
+      getInitConfigurationStrategy = function getInitConfigurationStrategy() {
+        return deepClone(initConfiguration);
+      };
+
+      beforeInitLoggerLog.drain();
+      isAlreadyInitialized = true;
+    },
+
+    /** @deprecated: use getGlobalContext instead */
+    getGlobalContext: globalContextManager.getContext,
+
+    /** @deprecated: use setGlobalContext instead */
+    setGlobalContext: globalContextManager.setContext,
+
+    /** @deprecated: use setGlobalContextProperty instead */
+    setGlobalContextProperty: globalContextManager.setContextProperty,
+
+    /** @deprecated: use removeGlobalContextProperty instead */
+    removeGlobalContextProperty: globalContextManager.removeContextProperty,
+    clearGlobalContext: globalContextManager.clearContext,
+    createLogger: function createLogger(name, conf) {
+      if (typeof conf == 'undefined') {
+        conf = {};
+      }
+
+      customLoggers[name] = new Logger(function () {
+        return _handleLogStrategy(this.arguments);
+      }, name, conf.handler, conf.level, conf.context);
+      return customLoggers[name];
+    },
+    getLogger: function getLogger(name) {
+      return customLoggers[name];
+    },
+    getInitConfiguration: function getInitConfiguration() {
+      return getInitConfigurationStrategy();
+    },
+    getInternalContext: function getInternalContext(startTime) {
+      return getInternalContextStrategy(startTime);
+    }
+  });
+
+  function canInitLogs(initConfiguration) {
+    if (isAlreadyInitialized) {
+      if (!initConfiguration.silentMultipleInit) {
+        display.error('DD_LOGS is already initialized.');
+      }
+
+      return false;
+    }
+
+    if (!initConfiguration.datakitUrl && !initConfiguration.datakitOrigin) {
+      display.error('datakitOrigin is not configured, no RUM data will be collected.');
+      return false;
+    }
+
+    return true;
+  }
+}

package/esm/boot/startLogs.js

@@ -0,0 +1,45 @@
+import { ErrorSource, LifeCycle, LifeCycleEventType } from '@cloudcare/browser-core';
+import { startLogsSessionManager } from '../domain/logsSessionManager';
+import { startLogsAssembly } from '../domain/assembly';
+import { startConsoleCollection } from '../domain/logsCollection/console/consoleCollection';
+import { startReportCollection } from '../domain/logsCollection/report/reportCollection';
+import { startNetworkErrorCollection } from '../domain/logsCollection/networkError/networkErrorCollection';
+import { startRuntimeErrorCollection } from '../domain/logsCollection/rumtimeError/runtimeErrorCollection';
+import { startLoggerCollection } from '../domain/logsCollection/logger/loggerCollection';
+import { startLogsBatch } from '../transport/startLogsBatch';
+import { StatusType } from '../domain/logger';
+import { startInternalContext } from '../domain/internalContext';
+export function startLogs(configuration, getCommonContext, mainLogger) {
+  var lifeCycle = new LifeCycle();
+
+  var reportError = function reportError(error) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: error.message,
+        date: error.startClocks.timeStamp,
+        error: {
+          origin: ErrorSource.AGENT // Todo: Remove in the next major release
+
+        },
+        origin: ErrorSource.AGENT,
+        status: StatusType.error
+      }
+    });
+  };
+
+  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, mainLogger, reportError);
+  startLogsBatch(configuration, lifeCycle, reportError);
+  var internalContext = startInternalContext(session);
+  return {
+    handleLog: _startLoggerCollection.handleLog,
+    getInternalContext: internalContext.get
+  };
+}

package/esm/domain/assembly.js

@@ -0,0 +1,59 @@
+import { ErrorSource, extend2Lev, createEventRateLimiter, getRelativeTime, withSnakeCaseKeys, LifeCycleEventType, deviceInfo, each, RumEventType, 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) {
+  var statusWithCustom = STATUSES.concat(['custom']);
+  var logRateLimiters = {};
+  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);
+
+    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
+    }, 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;
+    }
+
+    lifeCycle.notify(LifeCycleEventType.LOG_COLLECTED, withSnakeCaseKeys(log));
+  });
+}
+export function getRUMInternalContext(startTime) {
+  return getInternalContextFromRumGlobal(window.DATAFLUX_RUM);
+
+  function getInternalContextFromRumGlobal(rumGlobal) {
+    if (rumGlobal && rumGlobal.getInternalContext) {
+      return rumGlobal.getInternalContext(startTime);
+    }
+  }
+}
+export function resetRUMInternalContext() {
+  logsSentBeforeRumInjectionTelemetryAdded = false;
+}

package/esm/domain/configuration.js

@@ -0,0 +1,41 @@
+import { assign, ONE_KIBI_BYTE, validateAndBuildConfiguration, display, unique, RawReportType, isArray, every, ConsoleApiName, includes, values } from '@cloudcare/browser-core';
+import { buildEnv } from '../boot/buildEnv';
+/**
+ * arbitrary value, byte precision not needed
+ */
+
+export var DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE;
+export function validateAndBuildLogsConfiguration(initConfiguration) {
+  var baseConfiguration = validateAndBuildConfiguration(initConfiguration);
+  var forwardConsoleLogs = validateAndBuildForwardOption(initConfiguration.forwardConsoleLogs, values(ConsoleApiName), 'Forward Console Logs');
+  var forwardReports = validateAndBuildForwardOption(initConfiguration.forwardReports, values(RawReportType), 'Forward Reports');
+
+  if (!baseConfiguration || !forwardConsoleLogs || !forwardReports) {
+    return;
+  }
+
+  if (initConfiguration.forwardErrorsToLogs && !includes(forwardConsoleLogs, ConsoleApiName.error)) {
+    forwardConsoleLogs.push(ConsoleApiName.error);
+  }
+
+  return assign({
+    forwardErrorsToLogs: initConfiguration.forwardErrorsToLogs !== false,
+    forwardConsoleLogs: forwardConsoleLogs,
+    forwardReports: forwardReports,
+    requestErrorResponseLengthLimit: DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT
+  }, baseConfiguration, buildEnv);
+}
+export function validateAndBuildForwardOption(option, allowedValues, label) {
+  if (option === undefined) {
+    return [];
+  }
+
+  if (!(option === 'all' || isArray(option) && every(option, function (api) {
+    return includes(allowedValues, api);
+  }))) {
+    display.error(label + ' should be "all" or an array with allowed values "' + allowedValues.join('", "') + '"');
+    return;
+  }
+
+  return option === 'all' ? allowedValues : unique(option);
+}

package/esm/domain/internalContext.js

@@ -0,0 +1,15 @@
+export function startInternalContext(sessionManager) {
+  return {
+    get: function get(startTime) {
+      var trackedSession = sessionManager.findTrackedSession(startTime);
+
+      if (trackedSession) {
+        return {
+          session: {
+            id: trackedSession.id
+          }
+        };
+      }
+    }
+  };
+}

package/esm/domain/logger.js

@@ -1,27 +1,19 @@
-import { createContextManager, extend2Lev, keys, ErrorSource, jsonStringify } from '@cloudcare/browser-core';
+import { deepClone, assign, extend2Lev, createContextManager, ErrorSource, keys } from '@cloudcare/browser-core';
 export var StatusType = {
   debug: 'debug',
-  critical: 'critical',
   error: 'error',
   info: 'info',
-  warn: 'warning'
-}; // eslint-disable-next-line @typescript-eslint/no-redeclare
-
-var STATUS_PRIORITIES = {
-  [StatusType.debug]: 0,
-  [StatusType.info]: 1,
-  [StatusType.warn]: 2,
-  [StatusType.error]: 3,
-  [StatusType.critical]: 4
+  warn: 'warn',
+  critical: 'critical'
 };
-export var STATUSES = keys(StatusType);
 export var HandlerType = {
   console: 'console',
   http: 'http',
   silent: 'silent'
-}; // eslint-disable-next-line @typescript-eslint/no-redeclare
+};
+export var STATUSES = keys(StatusType); // eslint-disable-next-line @typescript-eslint/no-redeclare
 
-export function Logger(sendLog, handlerType, level, loggerContext) {
+export function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {
   this.contextManager = createContextManager();
 
   if (typeof handlerType === 'undefined') {
@@ -36,10 +28,14 @@ export 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(assign({}, loggerContext, name ? {
+    logger: {
+      name: name
+    }
+  } : undefined));
 }
 Logger.prototype = {
   log: function log(message, messageContext, status) {
@@ -47,26 +43,11 @@ Logger.prototype = {
       status = StatusType.info;
     }
 
-    if (STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[this.level]) {
-      switch (this.handlerType) {
-        case HandlerType.http:
-          var logMessage = extend2Lev({
-            message: message,
-            status: status
-          }, {
-            tags: this.contextManager.get()
-          }, messageContext);
-          this.sendLog(logMessage);
-          break;
-
-        case HandlerType.console:
-          console.log(status + ' : ' + message, extend2Lev(this.contextManager.get(), messageContext));
-          break;
-
-        case HandlerType.silent:
-          break;
-      }
-    }
+    this.handleLogStrategy({
+      message: message,
+      context: deepClone(messageContext),
+      status: status
+    }, this);
   },
   debug: function debug(message, messageContext) {
     this.log(message, messageContext, StatusType.debug);
@@ -91,6 +72,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);
   },
@@ -100,7 +84,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/esm/domain/logsCollection/console/consoleCollection.js

@@ -0,0 +1,31 @@
+import { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable, LifeCycleEventType } from '@cloudcare/browser-core';
+import { StatusType } from '../../logger';
+var LogStatusForApi = {
+  [ConsoleApiName.log]: StatusType.info,
+  [ConsoleApiName.debug]: StatusType.debug,
+  [ConsoleApiName.info]: StatusType.info,
+  [ConsoleApiName.warn]: StatusType.warn,
+  [ConsoleApiName.error]: StatusType.error
+};
+export function startConsoleCollection(configuration, lifeCycle) {
+  var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function (log) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message: log.message,
+        origin: ErrorSource.CONSOLE,
+        error: log.api === ConsoleApiName.error ? {
+          origin: ErrorSource.CONSOLE,
+          // Todo: Remove in the next major release
+          stack: log.stack
+        } : undefined,
+        status: LogStatusForApi[log.api]
+      }
+    });
+  });
+  return {
+    stop: function stop() {
+      consoleSubscription.unsubscribe();
+    }
+  };
+}

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

@@ -0,0 +1,38 @@
+import { includes, display, extend2Lev, ErrorSource, timeStampNow, LifeCycleEventType, isArray } from '@cloudcare/browser-core';
+import { StatusType, HandlerType } from '../../logger';
+export var STATUS_PRIORITIES = {
+  [StatusType.debug]: 0,
+  [StatusType.info]: 1,
+  [StatusType.warn]: 2,
+  [StatusType.error]: 3
+};
+export function startLoggerCollection(lifeCycle) {
+  function handleLog(logsMessage, logger, savedCommonContext, savedDate) {
+    var messageContext = logsMessage.context;
+
+    if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {
+      display(logsMessage.status, logsMessage.message, extend2Lev(logger.getContext(), messageContext));
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: savedDate || timeStampNow(),
+        message: logsMessage.message,
+        status: logsMessage.status,
+        origin: ErrorSource.LOGGER
+      },
+      messageContext: messageContext,
+      savedCommonContext: savedCommonContext,
+      logger: logger
+    });
+  }
+
+  return {
+    handleLog: handleLog
+  };
+}
+export function isAuthorized(status, handlerType, logger) {
+  var loggerHandler = logger.getHandler();
+  var sanitizedHandlerType = isArray(loggerHandler) ? loggerHandler : [loggerHandler];
+  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && includes(sanitizedHandlerType, handlerType);
+}

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

@@ -0,0 +1,223 @@
+import { ErrorSource, initXhrObservable, RequestType, initFetchObservable, computeStackTrace, toStackTraceString, noop, each, LifeCycleEventType, getStatusGroup, urlParse, replaceNumberCharByPath } from '@cloudcare/browser-core';
+import { StatusType } from '../../logger';
+export function startNetworkErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return {
+      stop: noop
+    };
+  }
+
+  var xhrSubscription = initXhrObservable().subscribe(function (context) {
+    if (context.state === 'complete') {
+      handleCompleteRequest(RequestType.XHR, context, configuration);
+    }
+  });
+  var fetchSubscription = initFetchObservable().subscribe(function (context) {
+    if (context.state === 'complete') {
+      handleCompleteRequest(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 = urlParse(request.url).getParse();
+      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+        rawLogsEvent: {
+          message: format(type) + ' error ' + request.method + ' ' + request.url,
+          date: request.startClocks.timeStamp,
+          error: {
+            origin: 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: getStatusGroup(request.status),
+            urlHost: urlObj.Host,
+            urlPath: urlObj.Path,
+            urlPathGroup: replaceNumberCharByPath(urlObj.Path)
+          },
+          status: StatusType.error,
+          origin: 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.
+
+export function computeXhrResponseData(xhr, configuration, callback) {
+  if (typeof xhr.response === 'string') {
+    callback(truncateResponseText(xhr.response, configuration));
+  } else {
+    callback(xhr.response);
+  }
+}
+export function computeFetchErrorText(error, configuration, callback) {
+  callback(truncateResponseText(toStackTraceString(computeStackTrace(error)), configuration));
+}
+export 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 (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
+    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;
+      each(chunks, function (chunk) {
+        completeBuffer.set(chunk, offset);
+        offset += chunk.length;
+      });
+    }
+
+    callback(undefined, completeBuffer.slice(0, limit), completeBuffer.length > limit);
+  }
+}