@webex/internal-plugin-metrics 3.12.0-next.5 → 3.12.0-next.50

package/dist/network-telemetry.js

@@ -0,0 +1,610 @@
+"use strict";
+
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
+var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
+var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
+var _Array$isArray = require("@babel/runtime-corejs2/core-js/array/is-array");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NETWORK_TELEMETRY_INTERVAL_MS = exports.NETWORK_REQUEST_SUMMARY_METRIC = void 0;
+exports.createNetworkErrorMetric = createNetworkErrorMetric;
+exports.createNetworkTelemetryCollector = createNetworkTelemetryCollector;
+exports.getOperation = getOperation;
+exports.shouldTrackNetworkRequest = shouldTrackNetworkRequest;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
+var _isFinite = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/number/is-finite"));
+var _isInteger = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/number/is-integer"));
+var _set = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/set"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _commonTimers = require("@webex/common-timers");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; } // TypeScript signatures own the types; JSDoc contains descriptions only.
+/* eslint valid-jsdoc: ["error", {"requireParamType": false, "requireReturnType": false}] */
+var NETWORK_REQUEST_SUMMARY_METRIC = exports.NETWORK_REQUEST_SUMMARY_METRIC = 'JS_SDK_NETWORK_REQUEST_SUMMARY';
+var NETWORK_TELEMETRY_INTERVAL_MS = exports.NETWORK_TELEMETRY_INTERVAL_MS = 10 * 60 * 1000;
+
+// Only segments that follow the SDK's static route naming convention are kept.
+// Numeric, mixed-case, encoded, and otherwise dynamic-looking values are redacted.
+// Lowercase alphabetic identifiers remain ambiguous because requests do not provide route templates.
+// Examples: `rooms/12345/messages` becomes `rooms/:id/messages`, and
+// `v1/rooms/65f81b6e-19dc-4a99-9175-59e9b34a5d42` becomes `v1/rooms/:id`.
+// `reports/a%2Fb/download` becomes `reports/:id/download`; `rooms`, `meeting-info`, and `v1` stay unchanged.
+var SAFE_ROUTE_SEGMENT = /^(?:[a-z]+(?:-[a-z]+)*|v[1-9]\d?)$/;
+var MAX_TRACKING_IDS = 10;
+var UNKNOWN = 'unknown';
+
+// Request events come from JavaScript in webex-core and have no shared TypeScript
+// contract. This local type intentionally contains only fields used by telemetry.
+
+/**
+ * Converts a non-empty string or number to a string.
+ * @param value Value to convert.
+ * @returns The converted string, or undefined for unsupported values.
+ */
+function toString(value) {
+  if (typeof value === 'number') {
+    return String(value);
+  }
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+/**
+ * Returns the normalized SDK service name.
+ * @param options Request options containing the service or API name.
+ * @returns The normalized service name.
+ */
+function getService(options) {
+  var service = options.service || options.api;
+  return typeof service === 'string' ? service.trim().toLowerCase() : '';
+}
+
+/**
+ * Replaces values that may be resource identifiers with a stable placeholder.
+ * @param segment Endpoint path segment.
+ * @returns The original static segment or the identifier placeholder.
+ */
+function normalizeRouteSegment(segment) {
+  return SAFE_ROUTE_SEGMENT.test(segment) ? segment : ':id';
+}
+
+/**
+ * Removes query data and redacts dynamic-looking endpoint segments.
+ * @param resource SDK resource path.
+ * @returns The normalized endpoint.
+ */
+function getOperation(resource) {
+  if (typeof resource !== 'string' || resource.length === 0) {
+    return UNKNOWN;
+  }
+  var path = resource.split(/[?#]/, 1)[0];
+  var segments = path.split('/').filter(Boolean).map(normalizeRouteSegment);
+  return segments.length > 0 ? segments.join('/') : 'root';
+}
+
+/**
+ * Extracts only the direct URL parts allowed in telemetry. URL credentials,
+ * query parameters, and fragments are not returned, while the pathname is
+ * converted to a sanitized endpoint.
+ * @param options Request options containing a direct URL.
+ * @returns The sanitized request identity, or undefined without a valid URL.
+ */
+function getDirectRequestIdentity(options) {
+  var value = options.uri || options.url;
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  try {
+    var requestUrl = new URL(value);
+    return {
+      host: requestUrl.host.toLowerCase() || UNKNOWN,
+      endPoint: getOperation(requestUrl.pathname)
+    };
+  } catch (_unused) {
+    return undefined;
+  }
+}
+
+/**
+ * Uses the logical service as the host because request:start may run before the
+ * service interceptor resolves a physical URL. Direct-URL requests use URL.host.
+ * @param options Request options used to resolve the identity.
+ * @returns The request host and endpoint.
+ */
+function getRequestIdentity(options) {
+  var directRequestIdentity = getDirectRequestIdentity(options);
+  var service = getService(options);
+  return {
+    host: service || (directRequestIdentity === null || directRequestIdentity === void 0 ? void 0 : directRequestIdentity.host) || UNKNOWN,
+    endPoint: options.resource ? getOperation(options.resource) : (directRequestIdentity === null || directRequestIdentity === void 0 ? void 0 : directRequestIdentity.endPoint) || UNKNOWN
+  };
+}
+
+/**
+ * Returns the measured network duration when both timing points are valid.
+ * @param options Request options containing network timing metadata.
+ * @returns The duration in milliseconds, or undefined when timing is unavailable.
+ */
+function getNetworkDuration(options) {
+  var _options$$timings, _options$$timings2;
+  var start = (_options$$timings = options.$timings) === null || _options$$timings === void 0 ? void 0 : _options$$timings.networkStart;
+  var end = (_options$$timings2 = options.$timings) === null || _options$$timings2 === void 0 ? void 0 : _options$$timings2.networkEnd;
+  return typeof start === 'number' && (0, _isFinite.default)(start) && typeof end === 'number' && (0, _isFinite.default)(end) && end >= start ? end - start : undefined;
+}
+
+/**
+ * Adds a completed request's network duration to its endpoint aggregate.
+ * @param metric Endpoint aggregate to update.
+ * @param options Request options containing network timing metadata.
+ * @returns Nothing.
+ */
+function recordNetworkDuration(metric, options) {
+  var duration = getNetworkDuration(options);
+  if (duration === undefined) {
+    return;
+  }
+  metric.totalNetworkDurationMs += duration;
+  metric.networkDurationsMs.push(duration);
+}
+
+/**
+ * Returns a normalized uppercase HTTP method.
+ * @param method HTTP method from the request options.
+ * @returns The normalized method.
+ */
+function getMethod(method) {
+  return typeof method === 'string' && method.length > 0 ? method.toUpperCase() : 'UNKNOWN';
+}
+
+/**
+ * Status zero represents a failure for which no valid HTTP response was received.
+ * @param reason Request failure.
+ * @returns A valid HTTP status code, or zero when no response was received.
+ */
+function getStatusCode(reason) {
+  var _reason$statusCode;
+  var statusCode = (_reason$statusCode = reason.statusCode) !== null && _reason$statusCode !== void 0 ? _reason$statusCode : reason.status;
+  return typeof statusCode === 'number' && (0, _isInteger.default)(statusCode) && statusCode >= 100 && statusCode <= 599 ? statusCode : 0;
+}
+
+/**
+ * Returns an error nested in a Webex HTTP error body.
+ * @param reason Request failure.
+ * @returns The wrapped error, when present.
+ */
+function getWrappedError(reason) {
+  return reason.body && (0, _typeof2.default)(reason.body) === 'object' ? reason.body : undefined;
+}
+
+/**
+ * Checks the timeout forms emitted by browser and Node transports.
+ * @param value Possible timeout signal.
+ * @returns Whether the value represents a timeout.
+ */
+function isTimeoutSignal(value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  var signal = value.toLowerCase();
+  return signal.includes('timeout') || signal === 'etimedout' || signal === 'esockettimedout';
+}
+
+/**
+ * Detects direct errors, transport errors wrapped in body, and requests whose
+ * measured network duration reached the configured timeout.
+ * @param reason Request failure.
+ * @param options Request options containing timeout metadata.
+ * @returns Whether the request timed out.
+ */
+function isTimeoutFailure(reason, options) {
+  var _options$$timings3, _options$$timings4;
+  var wrappedError = getWrappedError(reason);
+  if (isTimeoutSignal(reason.name) || isTimeoutSignal(reason.code) || isTimeoutSignal(reason.message) || isTimeoutSignal(reason.body) || isTimeoutSignal(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.name) || isTimeoutSignal(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.code) || isTimeoutSignal(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.message)) {
+    return true;
+  }
+  var start = (_options$$timings3 = options.$timings) === null || _options$$timings3 === void 0 ? void 0 : _options$$timings3.networkStart;
+  var end = (_options$$timings4 = options.$timings) === null || _options$$timings4 === void 0 ? void 0 : _options$$timings4.networkEnd;
+  return typeof options.timeout === 'number' && options.timeout > 0 && typeof start === 'number' && typeof end === 'number' && end >= start && end - start >= options.timeout;
+}
+
+/**
+ * Converts errors into a bounded set of categories for aggregation.
+ * @param reason Request failure.
+ * @param options Request options.
+ * @param statusCode Normalized status code.
+ * @returns The aggregate error category.
+ */
+function getErrorType(reason, options, statusCode) {
+  var name = typeof reason.name === 'string' ? reason.name.toLowerCase() : '';
+  if (name === 'aborterror') {
+    return 'aborted';
+  }
+  if (statusCode === 408 || statusCode === 504 || isTimeoutFailure(reason, options)) {
+    return 'timeout';
+  }
+  if (statusCode === 429) {
+    return 'rate_limited';
+  }
+  if (statusCode >= 500) {
+    return 'server_error';
+  }
+  if (statusCode >= 400) {
+    return 'client_error';
+  }
+  return statusCode === 0 || name !== null && name !== void 0 && name.includes('network') ? 'network_error' : 'request_error';
+}
+
+/**
+ * Returns the most specific available error code.
+ * @param reason Request failure.
+ * @returns The error code or the unknown fallback.
+ */
+function getErrorCode(reason) {
+  var wrappedError = getWrappedError(reason);
+  return toString(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.errorCode) || toString(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.code) || toString(reason.errorCode) || toString(reason.code) || UNKNOWN;
+}
+
+/**
+ * Returns the most specific available error message.
+ * @param reason Request failure.
+ * @returns The error message or the unknown fallback.
+ */
+function getErrorMessage(reason) {
+  var wrappedError = getWrappedError(reason);
+  return toString(wrappedError === null || wrappedError === void 0 ? void 0 : wrappedError.message) || toString(reason.body) || toString(reason.message) || UNKNOWN;
+}
+
+/**
+ * Excludes the transports used to submit telemetry, preventing self-reporting.
+ * @param options Request options.
+ * @returns Whether the request should be tracked.
+ */
+function shouldTrackNetworkRequest() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var service = getService(options);
+  return service !== 'metrics' && service !== 'unifiedtelemetry';
+}
+
+/**
+ * Creates the error entry produced by one failed request.
+ * @param options Request options.
+ * @param reason Request failure.
+ * @returns The normalized error metric.
+ */
+function createNetworkErrorMetric() {
+  var _options$headers;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var reason = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var identity = getRequestIdentity(options);
+  var statusCode = getStatusCode(reason);
+  // WebexTrackingIdInterceptor stores the request ID under this lowercase key.
+  var trackingId = toString((_options$headers = options.headers) === null || _options$headers === void 0 ? void 0 : _options$headers.trackingid);
+  return _objectSpread(_objectSpread({}, identity), {}, {
+    statusCode: statusCode,
+    errorCode: getErrorCode(reason),
+    method: getMethod(options.method),
+    errorType: getErrorType(reason, options, statusCode),
+    errorMessage: getErrorMessage(reason),
+    trackingIds: trackingId ? [trackingId] : [],
+    countError: 1
+  });
+}
+
+/**
+ * Creates an empty ten-minute telemetry window.
+ * @returns An empty telemetry aggregate.
+ */
+function createEmptyNetworkTelemetry() {
+  return {
+    metricsSummary: {
+      totalSendRequest: 0,
+      totalFailedRequest: 0,
+      totalRecvdResponse: 0,
+      totalFailedResponse: 0
+    },
+    metrics: [],
+    errorMetrics: [],
+    errorMetricsSummary: {}
+  };
+}
+
+/**
+ * Finds or creates the request counters for one host and endpoint.
+ * @param telemetry Current telemetry aggregate.
+ * @param options Request options.
+ * @returns The matching endpoint counters.
+ */
+function getRequestMetric(telemetry, options) {
+  var identity = getRequestIdentity(options);
+  var _iterator = _createForOfIteratorHelper(telemetry.metrics),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _metric = _step.value;
+      if (_metric.host === identity.host && _metric.endPoint === identity.endPoint) {
+        return _metric;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var metric = _objectSpread(_objectSpread({}, identity), {}, {
+    countSendRequest: 0,
+    countFailedRequest: 0,
+    countRecvdResponse: 0,
+    countFailedResponse: 0,
+    totalNetworkDurationMs: 0,
+    networkDurationsMs: []
+  });
+  telemetry.metrics.push(metric);
+  return metric;
+}
+
+/**
+ * Error entries aggregate only when every identifying field matches.
+ * @param first First error metric.
+ * @param second Second error metric.
+ * @returns Whether both errors belong to the same aggregate.
+ */
+function isSameError(first, second) {
+  return first.host === second.host && first.endPoint === second.endPoint && first.statusCode === second.statusCode && first.errorCode === second.errorCode && first.method === second.method && first.errorType === second.errorType && first.errorMessage === second.errorMessage;
+}
+
+/**
+ * Adds a failure to its error aggregate and retains at most ten unique IDs.
+ * @param telemetry Current telemetry aggregate.
+ * @param errorMetric Error metric to record.
+ * @returns Nothing.
+ */
+function recordError(telemetry, errorMetric) {
+  var _iterator2 = _createForOfIteratorHelper(telemetry.errorMetrics),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var existingMetric = _step2.value;
+      if (isSameError(existingMetric, errorMetric)) {
+        existingMetric.countError += 1;
+        var trackingId = errorMetric.trackingIds[0];
+        if (trackingId && existingMetric.trackingIds.length < MAX_TRACKING_IDS && !existingMetric.trackingIds.includes(trackingId)) {
+          existingMetric.trackingIds.push(trackingId);
+        }
+        return;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  telemetry.errorMetrics.push(errorMetric);
+}
+
+/**
+ * Returns a nearest-rank percentile from the measured durations.
+ * @param durations Measured network durations in milliseconds.
+ * @param percentile Percentile to calculate, between zero and one.
+ * @returns The percentile duration, or zero when no durations were measured.
+ */
+function getDurationPercentile(durations, percentile) {
+  if (durations.length === 0) {
+    return 0;
+  }
+  var sortedDurations = (0, _toConsumableArray2.default)(durations).sort(function (first, second) {
+    return first - second;
+  });
+  var rank = Math.max(1, Math.ceil(sortedDurations.length * percentile));
+  return sortedDurations[rank - 1];
+}
+
+/**
+ * Converts internal duration samples into the public endpoint metric shape.
+ * @param metric Internal endpoint aggregate.
+ * @returns Endpoint aggregate with average and p90 duration statistics.
+ */
+function serializeRequestMetric(metric) {
+  var measuredRequestCount = metric.networkDurationsMs.length;
+  return {
+    host: metric.host,
+    endPoint: metric.endPoint,
+    countSendRequest: metric.countSendRequest,
+    countFailedRequest: metric.countFailedRequest,
+    countRecvdResponse: metric.countRecvdResponse,
+    countFailedResponse: metric.countFailedResponse,
+    averageNetworkDurationMs: measuredRequestCount > 0 ? metric.totalNetworkDurationMs / measuredRequestCount : 0,
+    maxNetworkDurationP90Ms: getDurationPercentile(metric.networkDurationsMs, 0.9),
+    maxNetworkDurationP99Ms: getDurationPercentile(metric.networkDurationsMs, 0.99)
+  };
+}
+
+/**
+ * Converts the internal telemetry state into the submitted payload shape.
+ * @param telemetry Internal telemetry aggregate.
+ * @returns Telemetry payload with no internal duration samples.
+ */
+function serializeNetworkTelemetry(telemetry) {
+  return {
+    metricsSummary: telemetry.metricsSummary,
+    metrics: telemetry.metrics.map(serializeRequestMetric),
+    errorMetrics: telemetry.errorMetrics,
+    errorMetricsSummary: telemetry.errorMetricsSummary
+  };
+}
+
+/**
+ * Checks whether the current window contains anything worth flushing.
+ * @param telemetry Current telemetry aggregate.
+ * @returns Whether the aggregate contains request data.
+ */
+function hasNetworkTelemetry(telemetry) {
+  return telemetry.metrics.length > 0 || telemetry.errorMetrics.length > 0;
+}
+
+/**
+ * Creates a network telemetry collector and starts its periodic timer.
+ * @param options Submission callbacks.
+ * @returns The network telemetry collector.
+ */
+function createNetworkTelemetryCollector(_ref) {
+  var intervalMs = _ref.intervalMs,
+    onSubmissionFailure = _ref.onSubmissionFailure,
+    submitMetric = _ref.submitMetric;
+  var telemetry = createEmptyNetworkTelemetry();
+  var inFlightSubmissions = new _set.default();
+
+  /**
+   * Tracks a submission until it settles so shutdown can wait for requests
+   * whose telemetry window has already been reset.
+   * @param submission Submission promise.
+   * @returns The tracked submission promise.
+   */
+  function trackSubmission(submission) {
+    inFlightSubmissions.add(submission);
+    submission.then(function () {
+      return inFlightSubmissions.delete(submission);
+    }, function () {
+      return inFlightSubmissions.delete(submission);
+    });
+    return submission;
+  }
+
+  /**
+   * Records a request being sent.
+   * @param options Request options.
+   * @returns Nothing.
+   */
+  function recordRequest() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (!shouldTrackNetworkRequest(options)) {
+      return;
+    }
+    telemetry.metricsSummary.totalSendRequest += 1;
+    getRequestMetric(telemetry, options).countSendRequest += 1;
+  }
+
+  /**
+   * Records a successful response.
+   * @param options Request options.
+   * @returns Nothing.
+   */
+  function recordResponse() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (!shouldTrackNetworkRequest(options)) {
+      return;
+    }
+    telemetry.metricsSummary.totalRecvdResponse += 1;
+    var requestMetric = getRequestMetric(telemetry, options);
+    requestMetric.countRecvdResponse += 1;
+    recordNetworkDuration(requestMetric, options);
+  }
+
+  /**
+   * A real HTTP status is a failed response. Status zero means the request
+   * failed before the SDK received a valid HTTP response.
+   * @param options Request options.
+   * @param reason Request failure.
+   * @returns Nothing.
+   */
+  function recordFailure() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var reason = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (!shouldTrackNetworkRequest(options)) {
+      return;
+    }
+    var errorMetric = createNetworkErrorMetric(options, reason);
+    var requestMetric = getRequestMetric(telemetry, options);
+    recordNetworkDuration(requestMetric, options);
+    if (errorMetric.statusCode === 0) {
+      telemetry.metricsSummary.totalFailedRequest += 1;
+      requestMetric.countFailedRequest += 1;
+    } else {
+      telemetry.metricsSummary.totalRecvdResponse += 1;
+      telemetry.metricsSummary.totalFailedResponse += 1;
+      requestMetric.countRecvdResponse += 1;
+      requestMetric.countFailedResponse += 1;
+    }
+    recordError(telemetry, errorMetric);
+    var statusCode = String(errorMetric.statusCode);
+    var statusSummary = telemetry.errorMetricsSummary[statusCode];
+    if (statusSummary) {
+      statusSummary.count += 1;
+    } else {
+      telemetry.errorMetricsSummary[statusCode] = {
+        count: 1
+      };
+    }
+  }
+
+  /**
+   * Submits the completed window and starts collecting the next one.
+   * @returns A promise that settles after submission succeeds or is reported as failed.
+   */
+  function submitSummary() {
+    var completedTelemetry = telemetry;
+    var payload = serializeNetworkTelemetry(completedTelemetry);
+
+    // Reset before submission so requests emitted by the telemetry transport,
+    // or while it is pending, cannot mutate the completed window.
+    telemetry = createEmptyNetworkTelemetry();
+    try {
+      var submission = _promise.default.resolve(submitMetric(NETWORK_REQUEST_SUMMARY_METRIC, {
+        type: 'operational',
+        tags: {},
+        fields: completedTelemetry.metricsSummary,
+        eventPayload: payload
+      })).then(function () {
+        return undefined;
+      }, function () {
+        onSubmissionFailure();
+      });
+      return trackSubmission(submission);
+    } catch (_unused2) {
+      // submitMetric may throw before returning a promise.
+      onSubmissionFailure();
+      return _promise.default.resolve();
+    }
+  }
+  var telemetryIntervalMs = typeof intervalMs === 'number' && (0, _isFinite.default)(intervalMs) && intervalMs > 0 ? intervalMs : NETWORK_TELEMETRY_INTERVAL_MS;
+  var telemetryInterval = (0, _commonTimers.safeSetInterval)(submitSummary, telemetryIntervalMs);
+
+  /**
+   * Submits the current non-empty window immediately.
+   * @returns A promise that settles after submission succeeds or is reported as failed.
+   */
+  function flush() {
+    return hasNetworkTelemetry(telemetry) ? submitSummary() : _promise.default.resolve();
+  }
+
+  /**
+   * Stops periodic submission and releases data from the current window.
+   * @returns A promise that settles after the final window is submitted or failure is reported.
+   */
+  function stop() {
+    clearInterval(telemetryInterval);
+    flush();
+    return _promise.default.all(inFlightSubmissions).then(function () {
+      return undefined;
+    });
+  }
+  return {
+    recordRequest: recordRequest,
+    recordResponse: recordResponse,
+    recordFailure: recordFailure,
+    flush: flush,
+    stop: stop
+  };
+}
+//# sourceMappingURL=network-telemetry.js.map