@opentelemetry/otlp-exporter-base - npm Package Compare versions

Comparing version 0.35.1 to 0.36.0

build/esm/platform/browser/util.js

@@ -45,2 +45,3 @@ var __assign = (this && this.__assign) || function () {
 import { OTLPExporterError } from '../../types';
+import { DEFAULT_EXPORT_MAX_ATTEMPTS, DEFAULT_EXPORT_INITIAL_BACKOFF, DEFAULT_EXPORT_BACKOFF_MULTIPLIER, DEFAULT_EXPORT_MAX_BACKOFF, isExportRetryable, parseRetryAfterToMills, } from '../../util';
 /**
@@ -74,37 +75,80 @@ * Send metrics/spans using browser navigator.sendBeacon
 export function sendWithXhr(body, url, headers, exporterTimeout, onSuccess, onError) {
-    var reqIsDestroyed;
+    var retryTimer;
+    var xhr;
+    var reqIsDestroyed = false;
     var exporterTimer = setTimeout(function () {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        xhr.abort();
+        if (xhr.readyState === XMLHttpRequest.DONE) {
+            var err = new OTLPExporterError('Request Timeout');
+            onError(err);
+        }
+        else {
+            xhr.abort();
+        }
     }, exporterTimeout);
-    var xhr = new XMLHttpRequest();
-    xhr.open('POST', url);
-    var defaultHeaders = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    };
-    Object.entries(__assign(__assign({}, defaultHeaders), headers)).forEach(function (_a) {
-        var _b = __read(_a, 2), k = _b[0], v = _b[1];
-        xhr.setRequestHeader(k, v);
-    });
-    xhr.send(body);
-    xhr.onreadystatechange = function () {
-        if (xhr.readyState === XMLHttpRequest.DONE) {
-            if (xhr.status >= 200 && xhr.status <= 299) {
-                clearTimeout(exporterTimer);
-                diag.debug('xhr success', body);
-                onSuccess();
+    var sendWithRetry = function (retries, minDelay) {
+        if (retries === void 0) { retries = DEFAULT_EXPORT_MAX_ATTEMPTS; }
+        if (minDelay === void 0) { minDelay = DEFAULT_EXPORT_INITIAL_BACKOFF; }
+        xhr = new XMLHttpRequest();
+        xhr.open('POST', url);
+        var defaultHeaders = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+        Object.entries(__assign(__assign({}, defaultHeaders), headers)).forEach(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            xhr.setRequestHeader(k, v);
+        });
+        xhr.send(body);
+        xhr.onreadystatechange = function () {
+            if (xhr.readyState === XMLHttpRequest.DONE && reqIsDestroyed === false) {
+                if (xhr.status >= 200 && xhr.status <= 299) {
+                    diag.debug('xhr success', body);
+                    onSuccess();
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
+                else if (xhr.status && isExportRetryable(xhr.status) && retries > 0) {
+                    var retryTime = void 0;
+                    minDelay = DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                    // retry after interval specified in Retry-After header
+                    if (xhr.getResponseHeader('Retry-After')) {
+                        retryTime = parseRetryAfterToMills(xhr.getResponseHeader('Retry-After'));
+                    }
+                    else {
+                        // exponential backoff with jitter
+                        retryTime = Math.round(Math.random() * (DEFAULT_EXPORT_MAX_BACKOFF - minDelay) + minDelay);
+                    }
+                    retryTimer = setTimeout(function () {
+                        sendWithRetry(retries - 1, minDelay);
+                    }, retryTime);
+                }
+                else {
+                    var error = new OTLPExporterError("Failed to export with XHR (status: " + xhr.status + ")", xhr.status);
+                    onError(error);
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
             }
-            else if (reqIsDestroyed) {
-                var error = new OTLPExporterError('Request Timeout', xhr.status);
-                onError(error);
+        };
+        xhr.onabort = function () {
+            if (reqIsDestroyed) {
+                var err = new OTLPExporterError('Request Timeout');
+                onError(err);
             }
-            else {
-                var error = new OTLPExporterError("Failed to export with XHR (status: " + xhr.status + ")", xhr.status);
-                clearTimeout(exporterTimer);
-                onError(error);
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
+        xhr.onerror = function () {
+            if (reqIsDestroyed) {
+                var err = new OTLPExporterError('Request Timeout');
+                onError(err);
             }
-        }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
     };
+    sendWithRetry();
 }
 //# sourceMappingURL=util.js.map

build/esm/platform/node/util.js

@@ -36,2 +36,3 @@ var __assign = (this && this.__assign) || function () {
 import { OTLPExporterError } from '../../types';
+import { DEFAULT_EXPORT_MAX_ATTEMPTS, DEFAULT_EXPORT_INITIAL_BACKOFF, DEFAULT_EXPORT_BACKOFF_MULTIPLIER, DEFAULT_EXPORT_MAX_BACKOFF, isExportRetryable, parseRetryAfterToMills, } from '../../util';
 /**
@@ -48,12 +49,16 @@ * Sends data using http
     var parsedUrl = new url.URL(collector.url);
-    var reqIsDestroyed;
     var nodeVersion = Number(process.versions.node.split('.')[0]);
+    var retryTimer;
+    var req;
+    var reqIsDestroyed = false;
     var exporterTimer = setTimeout(function () {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        // req.abort() was deprecated since v14
-        if (nodeVersion >= 14) {
-            req.destroy();
+        if (req.destroyed) {
+            var err = new OTLPExporterError('Request Timeout');
+            onError(err);
         }
         else {
-            req.abort();
+            // req.abort() was deprecated since v14
+            nodeVersion >= 14 ? req.destroy() : req.abort();
         }
@@ -70,50 +75,87 @@ }, exporterTimeout);
     var request = parsedUrl.protocol === 'http:' ? http.request : https.request;
-    var req = request(options, function (res) {
-        var responseData = '';
-        res.on('data', function (chunk) { return (responseData += chunk); });
-        res.on('aborted', function () {
+    var sendWithRetry = function (retries, minDelay) {
+        if (retries === void 0) { retries = DEFAULT_EXPORT_MAX_ATTEMPTS; }
+        if (minDelay === void 0) { minDelay = DEFAULT_EXPORT_INITIAL_BACKOFF; }
+        req = request(options, function (res) {
+            var responseData = '';
+            res.on('data', function (chunk) { return (responseData += chunk); });
+            res.on('aborted', function () {
+                if (reqIsDestroyed) {
+                    var err = new OTLPExporterError('Request Timeout');
+                    onError(err);
+                }
+            });
+            res.on('end', function () {
+                if (reqIsDestroyed === false) {
+                    if (res.statusCode && res.statusCode < 299) {
+                        diag.debug("statusCode: " + res.statusCode, responseData);
+                        onSuccess();
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                    else if (res.statusCode &&
+                        isExportRetryable(res.statusCode) &&
+                        retries > 0) {
+                        var retryTime = void 0;
+                        minDelay = DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                        // retry after interval specified in Retry-After header
+                        if (res.headers['retry-after']) {
+                            retryTime = parseRetryAfterToMills(res.headers['retry-after']);
+                        }
+                        else {
+                            // exponential backoff with jitter
+                            retryTime = Math.round(Math.random() * (DEFAULT_EXPORT_MAX_BACKOFF - minDelay) +
+                                minDelay);
+                        }
+                        retryTimer = setTimeout(function () {
+                            sendWithRetry(retries - 1, minDelay);
+                        }, retryTime);
+                    }
+                    else {
+                        var error = new OTLPExporterError(res.statusMessage, res.statusCode, responseData);
+                        onError(error);
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                }
+            });
+        });
+        req.on('error', function (error) {
             if (reqIsDestroyed) {
+                var err = new OTLPExporterError('Request Timeout', error.code);
+                onError(err);
+            }
+            else {
+                onError(error);
+            }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        });
+        req.on('abort', function () {
+            if (reqIsDestroyed) {
                 var err = new OTLPExporterError('Request Timeout');
                 onError(err);
             }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
         });
-        res.on('end', function () {
-            if (!reqIsDestroyed) {
-                if (res.statusCode && res.statusCode < 299) {
-                    diag.debug("statusCode: " + res.statusCode, responseData);
-                    onSuccess();
-                }
-                else {
-                    var error = new OTLPExporterError(res.statusMessage, res.statusCode, responseData);
-                    onError(error);
-                }
-                clearTimeout(exporterTimer);
+        switch (collector.compression) {
+            case CompressionAlgorithm.GZIP: {
+                req.setHeader('Content-Encoding', 'gzip');
+                var dataStream = readableFromBuffer(data);
+                dataStream
+                    .on('error', onError)
+                    .pipe(zlib.createGzip())
+                    .on('error', onError)
+                    .pipe(req);
+                break;
             }
-        });
-    });
-    req.on('error', function (error) {
-        if (reqIsDestroyed) {
-            var err = new OTLPExporterError('Request Timeout', error.code);
-            onError(err);
+            default:
+                req.end(data);
+                break;
         }
-        else {
-            clearTimeout(exporterTimer);
-            onError(error);
-        }
-    });
-    switch (collector.compression) {
-        case CompressionAlgorithm.GZIP: {
-            req.setHeader('Content-Encoding', 'gzip');
-            var dataStream = readableFromBuffer(data);
-            dataStream
-                .on('error', onError)
-                .pipe(zlib.createGzip())
-                .on('error', onError)
-                .pipe(req);
-            break;
-        }
-        default:
-            req.end(data);
-            break;
-    }
+    };
+    sendWithRetry();
 }
@@ -120,0 +162,0 @@ function readableFromBuffer(buff) {

build/esm/util.d.ts

@@ -0,1 +1,5 @@
+export declare const DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+export declare const DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+export declare const DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+export declare const DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -26,2 +30,4 @@ * Parses headers from config leaving only those that have defined values
 export declare function invalidTimeout(timeout: number, defaultTimeout: number): number;
+export declare function isExportRetryable(statusCode: number): boolean;
+export declare function parseRetryAfterToMills(retryAfter?: string | null): number;
 //# sourceMappingURL=util.d.ts.map

build/esm/util.js

@@ -35,2 +35,6 @@ /*
 var DEFAULT_TRACE_TIMEOUT = 10000;
+export var DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+export var DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+export var DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+export var DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -117,2 +121,21 @@ * Parses headers from config leaving only those that have defined values
 }
+export function isExportRetryable(statusCode) {
+    var retryCodes = [429, 502, 503, 504];
+    return retryCodes.includes(statusCode);
+}
+export function parseRetryAfterToMills(retryAfter) {
+    if (retryAfter == null) {
+        return -1;
+    }
+    var seconds = Number.parseInt(retryAfter, 10);
+    if (Number.isInteger(seconds)) {
+        return seconds > 0 ? seconds * 1000 : -1;
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives
+    var delay = new Date(retryAfter).getTime() - Date.now();
+    if (delay >= 0) {
+        return delay;
+    }
+    return 0;
+}
 //# sourceMappingURL=util.js.map

build/esm/version.d.ts

@@ -1,2 +0,2 @@
-export declare const VERSION = "0.35.1";
+export declare const VERSION = "0.36.0";
 //# sourceMappingURL=version.d.ts.map

build/esm/version.js

@@ -17,3 +17,3 @@ /*
 // this is autogenerated file, see scripts/version-update.js
-export var VERSION = '0.35.1';
+export var VERSION = '0.36.0';
 //# sourceMappingURL=version.js.map

build/esnext/platform/browser/util.js

@@ -18,2 +18,3 @@ /*
 import { OTLPExporterError } from '../../types';
+import { DEFAULT_EXPORT_MAX_ATTEMPTS, DEFAULT_EXPORT_INITIAL_BACKOFF, DEFAULT_EXPORT_BACKOFF_MULTIPLIER, DEFAULT_EXPORT_MAX_BACKOFF, isExportRetryable, parseRetryAfterToMills, } from '../../util';
 /**
@@ -47,36 +48,77 @@ * Send metrics/spans using browser navigator.sendBeacon
 export function sendWithXhr(body, url, headers, exporterTimeout, onSuccess, onError) {
-    let reqIsDestroyed;
+    let retryTimer;
+    let xhr;
+    let reqIsDestroyed = false;
     const exporterTimer = setTimeout(() => {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        xhr.abort();
+        if (xhr.readyState === XMLHttpRequest.DONE) {
+            const err = new OTLPExporterError('Request Timeout');
+            onError(err);
+        }
+        else {
+            xhr.abort();
+        }
     }, exporterTimeout);
-    const xhr = new XMLHttpRequest();
-    xhr.open('POST', url);
-    const defaultHeaders = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    };
-    Object.entries(Object.assign(Object.assign({}, defaultHeaders), headers)).forEach(([k, v]) => {
-        xhr.setRequestHeader(k, v);
-    });
-    xhr.send(body);
-    xhr.onreadystatechange = () => {
-        if (xhr.readyState === XMLHttpRequest.DONE) {
-            if (xhr.status >= 200 && xhr.status <= 299) {
-                clearTimeout(exporterTimer);
-                diag.debug('xhr success', body);
-                onSuccess();
+    const sendWithRetry = (retries = DEFAULT_EXPORT_MAX_ATTEMPTS, minDelay = DEFAULT_EXPORT_INITIAL_BACKOFF) => {
+        xhr = new XMLHttpRequest();
+        xhr.open('POST', url);
+        const defaultHeaders = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+        Object.entries(Object.assign(Object.assign({}, defaultHeaders), headers)).forEach(([k, v]) => {
+            xhr.setRequestHeader(k, v);
+        });
+        xhr.send(body);
+        xhr.onreadystatechange = () => {
+            if (xhr.readyState === XMLHttpRequest.DONE && reqIsDestroyed === false) {
+                if (xhr.status >= 200 && xhr.status <= 299) {
+                    diag.debug('xhr success', body);
+                    onSuccess();
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
+                else if (xhr.status && isExportRetryable(xhr.status) && retries > 0) {
+                    let retryTime;
+                    minDelay = DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                    // retry after interval specified in Retry-After header
+                    if (xhr.getResponseHeader('Retry-After')) {
+                        retryTime = parseRetryAfterToMills(xhr.getResponseHeader('Retry-After'));
+                    }
+                    else {
+                        // exponential backoff with jitter
+                        retryTime = Math.round(Math.random() * (DEFAULT_EXPORT_MAX_BACKOFF - minDelay) + minDelay);
+                    }
+                    retryTimer = setTimeout(() => {
+                        sendWithRetry(retries - 1, minDelay);
+                    }, retryTime);
+                }
+                else {
+                    const error = new OTLPExporterError(`Failed to export with XHR (status: ${xhr.status})`, xhr.status);
+                    onError(error);
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
             }
-            else if (reqIsDestroyed) {
-                const error = new OTLPExporterError('Request Timeout', xhr.status);
-                onError(error);
+        };
+        xhr.onabort = () => {
+            if (reqIsDestroyed) {
+                const err = new OTLPExporterError('Request Timeout');
+                onError(err);
             }
-            else {
-                const error = new OTLPExporterError(`Failed to export with XHR (status: ${xhr.status})`, xhr.status);
-                clearTimeout(exporterTimer);
-                onError(error);
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
+        xhr.onerror = () => {
+            if (reqIsDestroyed) {
+                const err = new OTLPExporterError('Request Timeout');
+                onError(err);
             }
-        }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
     };
+    sendWithRetry();
 }
 //# sourceMappingURL=util.js.map

build/esnext/platform/node/util.js

@@ -25,2 +25,3 @@ /*
 import { OTLPExporterError } from '../../types';
+import { DEFAULT_EXPORT_MAX_ATTEMPTS, DEFAULT_EXPORT_INITIAL_BACKOFF, DEFAULT_EXPORT_BACKOFF_MULTIPLIER, DEFAULT_EXPORT_MAX_BACKOFF, isExportRetryable, parseRetryAfterToMills, } from '../../util';
 /**
@@ -37,12 +38,16 @@ * Sends data using http
     const parsedUrl = new url.URL(collector.url);
-    let reqIsDestroyed;
     const nodeVersion = Number(process.versions.node.split('.')[0]);
+    let retryTimer;
+    let req;
+    let reqIsDestroyed = false;
     const exporterTimer = setTimeout(() => {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        // req.abort() was deprecated since v14
-        if (nodeVersion >= 14) {
-            req.destroy();
+        if (req.destroyed) {
+            const err = new OTLPExporterError('Request Timeout');
+            onError(err);
         }
         else {
-            req.abort();
+            // req.abort() was deprecated since v14
+            nodeVersion >= 14 ? req.destroy() : req.abort();
         }
@@ -59,50 +64,85 @@ }, exporterTimeout);
     const request = parsedUrl.protocol === 'http:' ? http.request : https.request;
-    const req = request(options, (res) => {
-        let responseData = '';
-        res.on('data', chunk => (responseData += chunk));
-        res.on('aborted', () => {
+    const sendWithRetry = (retries = DEFAULT_EXPORT_MAX_ATTEMPTS, minDelay = DEFAULT_EXPORT_INITIAL_BACKOFF) => {
+        req = request(options, (res) => {
+            let responseData = '';
+            res.on('data', chunk => (responseData += chunk));
+            res.on('aborted', () => {
+                if (reqIsDestroyed) {
+                    const err = new OTLPExporterError('Request Timeout');
+                    onError(err);
+                }
+            });
+            res.on('end', () => {
+                if (reqIsDestroyed === false) {
+                    if (res.statusCode && res.statusCode < 299) {
+                        diag.debug(`statusCode: ${res.statusCode}`, responseData);
+                        onSuccess();
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                    else if (res.statusCode &&
+                        isExportRetryable(res.statusCode) &&
+                        retries > 0) {
+                        let retryTime;
+                        minDelay = DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                        // retry after interval specified in Retry-After header
+                        if (res.headers['retry-after']) {
+                            retryTime = parseRetryAfterToMills(res.headers['retry-after']);
+                        }
+                        else {
+                            // exponential backoff with jitter
+                            retryTime = Math.round(Math.random() * (DEFAULT_EXPORT_MAX_BACKOFF - minDelay) +
+                                minDelay);
+                        }
+                        retryTimer = setTimeout(() => {
+                            sendWithRetry(retries - 1, minDelay);
+                        }, retryTime);
+                    }
+                    else {
+                        const error = new OTLPExporterError(res.statusMessage, res.statusCode, responseData);
+                        onError(error);
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                }
+            });
+        });
+        req.on('error', (error) => {
             if (reqIsDestroyed) {
+                const err = new OTLPExporterError('Request Timeout', error.code);
+                onError(err);
+            }
+            else {
+                onError(error);
+            }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        });
+        req.on('abort', () => {
+            if (reqIsDestroyed) {
                 const err = new OTLPExporterError('Request Timeout');
                 onError(err);
             }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
         });
-        res.on('end', () => {
-            if (!reqIsDestroyed) {
-                if (res.statusCode && res.statusCode < 299) {
-                    diag.debug(`statusCode: ${res.statusCode}`, responseData);
-                    onSuccess();
-                }
-                else {
-                    const error = new OTLPExporterError(res.statusMessage, res.statusCode, responseData);
-                    onError(error);
-                }
-                clearTimeout(exporterTimer);
+        switch (collector.compression) {
+            case CompressionAlgorithm.GZIP: {
+                req.setHeader('Content-Encoding', 'gzip');
+                const dataStream = readableFromBuffer(data);
+                dataStream
+                    .on('error', onError)
+                    .pipe(zlib.createGzip())
+                    .on('error', onError)
+                    .pipe(req);
+                break;
             }
-        });
-    });
-    req.on('error', (error) => {
-        if (reqIsDestroyed) {
-            const err = new OTLPExporterError('Request Timeout', error.code);
-            onError(err);
+            default:
+                req.end(data);
+                break;
         }
-        else {
-            clearTimeout(exporterTimer);
-            onError(error);
-        }
-    });
-    switch (collector.compression) {
-        case CompressionAlgorithm.GZIP: {
-            req.setHeader('Content-Encoding', 'gzip');
-            const dataStream = readableFromBuffer(data);
-            dataStream
-                .on('error', onError)
-                .pipe(zlib.createGzip())
-                .on('error', onError)
-                .pipe(req);
-            break;
-        }
-        default:
-            req.end(data);
-            break;
-    }
+    };
+    sendWithRetry();
 }
@@ -109,0 +149,0 @@ function readableFromBuffer(buff) {

build/esnext/util.d.ts

@@ -0,1 +1,5 @@
+export declare const DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+export declare const DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+export declare const DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+export declare const DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -26,2 +30,4 @@ * Parses headers from config leaving only those that have defined values
 export declare function invalidTimeout(timeout: number, defaultTimeout: number): number;
+export declare function isExportRetryable(statusCode: number): boolean;
+export declare function parseRetryAfterToMills(retryAfter?: string | null): number;
 //# sourceMappingURL=util.d.ts.map

build/esnext/util.js

@@ -19,2 +19,6 @@ /*
 const DEFAULT_TRACE_TIMEOUT = 10000;
+export const DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+export const DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+export const DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+export const DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -99,2 +103,21 @@ * Parses headers from config leaving only those that have defined values
 }
+export function isExportRetryable(statusCode) {
+    const retryCodes = [429, 502, 503, 504];
+    return retryCodes.includes(statusCode);
+}
+export function parseRetryAfterToMills(retryAfter) {
+    if (retryAfter == null) {
+        return -1;
+    }
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (Number.isInteger(seconds)) {
+        return seconds > 0 ? seconds * 1000 : -1;
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives
+    const delay = new Date(retryAfter).getTime() - Date.now();
+    if (delay >= 0) {
+        return delay;
+    }
+    return 0;
+}
 //# sourceMappingURL=util.js.map

build/esnext/version.d.ts

@@ -1,2 +0,2 @@
-export declare const VERSION = "0.35.1";
+export declare const VERSION = "0.36.0";
 //# sourceMappingURL=version.d.ts.map

build/esnext/version.js

@@ -17,3 +17,3 @@ /*
 // this is autogenerated file, see scripts/version-update.js
-export const VERSION = '0.35.1';
+export const VERSION = '0.36.0';
 //# sourceMappingURL=version.js.map

build/src/platform/browser/util.js

@@ -21,2 +21,3 @@ "use strict";
 const types_1 = require("../../types");
+const util_1 = require("../../util");
 /**
@@ -51,37 +52,78 @@ * Send metrics/spans using browser navigator.sendBeacon
 function sendWithXhr(body, url, headers, exporterTimeout, onSuccess, onError) {
-    let reqIsDestroyed;
+    let retryTimer;
+    let xhr;
+    let reqIsDestroyed = false;
     const exporterTimer = setTimeout(() => {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        xhr.abort();
+        if (xhr.readyState === XMLHttpRequest.DONE) {
+            const err = new types_1.OTLPExporterError('Request Timeout');
+            onError(err);
+        }
+        else {
+            xhr.abort();
+        }
     }, exporterTimeout);
-    const xhr = new XMLHttpRequest();
-    xhr.open('POST', url);
-    const defaultHeaders = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    };
-    Object.entries(Object.assign(Object.assign({}, defaultHeaders), headers)).forEach(([k, v]) => {
-        xhr.setRequestHeader(k, v);
-    });
-    xhr.send(body);
-    xhr.onreadystatechange = () => {
-        if (xhr.readyState === XMLHttpRequest.DONE) {
-            if (xhr.status >= 200 && xhr.status <= 299) {
-                clearTimeout(exporterTimer);
-                api_1.diag.debug('xhr success', body);
-                onSuccess();
+    const sendWithRetry = (retries = util_1.DEFAULT_EXPORT_MAX_ATTEMPTS, minDelay = util_1.DEFAULT_EXPORT_INITIAL_BACKOFF) => {
+        xhr = new XMLHttpRequest();
+        xhr.open('POST', url);
+        const defaultHeaders = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+        Object.entries(Object.assign(Object.assign({}, defaultHeaders), headers)).forEach(([k, v]) => {
+            xhr.setRequestHeader(k, v);
+        });
+        xhr.send(body);
+        xhr.onreadystatechange = () => {
+            if (xhr.readyState === XMLHttpRequest.DONE && reqIsDestroyed === false) {
+                if (xhr.status >= 200 && xhr.status <= 299) {
+                    api_1.diag.debug('xhr success', body);
+                    onSuccess();
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
+                else if (xhr.status && (0, util_1.isExportRetryable)(xhr.status) && retries > 0) {
+                    let retryTime;
+                    minDelay = util_1.DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                    // retry after interval specified in Retry-After header
+                    if (xhr.getResponseHeader('Retry-After')) {
+                        retryTime = (0, util_1.parseRetryAfterToMills)(xhr.getResponseHeader('Retry-After'));
+                    }
+                    else {
+                        // exponential backoff with jitter
+                        retryTime = Math.round(Math.random() * (util_1.DEFAULT_EXPORT_MAX_BACKOFF - minDelay) + minDelay);
+                    }
+                    retryTimer = setTimeout(() => {
+                        sendWithRetry(retries - 1, minDelay);
+                    }, retryTime);
+                }
+                else {
+                    const error = new types_1.OTLPExporterError(`Failed to export with XHR (status: ${xhr.status})`, xhr.status);
+                    onError(error);
+                    clearTimeout(exporterTimer);
+                    clearTimeout(retryTimer);
+                }
             }
-            else if (reqIsDestroyed) {
-                const error = new types_1.OTLPExporterError('Request Timeout', xhr.status);
-                onError(error);
+        };
+        xhr.onabort = () => {
+            if (reqIsDestroyed) {
+                const err = new types_1.OTLPExporterError('Request Timeout');
+                onError(err);
             }
-            else {
-                const error = new types_1.OTLPExporterError(`Failed to export with XHR (status: ${xhr.status})`, xhr.status);
-                clearTimeout(exporterTimer);
-                onError(error);
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
+        xhr.onerror = () => {
+            if (reqIsDestroyed) {
+                const err = new types_1.OTLPExporterError('Request Timeout');
+                onError(err);
             }
-        }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        };
     };
+    sendWithRetry();
 }
 exports.sendWithXhr = sendWithXhr;
 //# sourceMappingURL=util.js.map

build/src/platform/node/util.js

@@ -28,2 +28,3 @@ "use strict";
 const types_2 = require("../../types");
+const util_1 = require("../../util");
 /**
@@ -40,12 +41,16 @@ * Sends data using http
     const parsedUrl = new url.URL(collector.url);
-    let reqIsDestroyed;
     const nodeVersion = Number(process.versions.node.split('.')[0]);
+    let retryTimer;
+    let req;
+    let reqIsDestroyed = false;
     const exporterTimer = setTimeout(() => {
+        clearTimeout(retryTimer);
         reqIsDestroyed = true;
-        // req.abort() was deprecated since v14
-        if (nodeVersion >= 14) {
-            req.destroy();
+        if (req.destroyed) {
+            const err = new types_2.OTLPExporterError('Request Timeout');
+            onError(err);
         }
         else {
-            req.abort();
+            // req.abort() was deprecated since v14
+            nodeVersion >= 14 ? req.destroy() : req.abort();
         }
@@ -62,50 +67,85 @@ }, exporterTimeout);
     const request = parsedUrl.protocol === 'http:' ? http.request : https.request;
-    const req = request(options, (res) => {
-        let responseData = '';
-        res.on('data', chunk => (responseData += chunk));
-        res.on('aborted', () => {
+    const sendWithRetry = (retries = util_1.DEFAULT_EXPORT_MAX_ATTEMPTS, minDelay = util_1.DEFAULT_EXPORT_INITIAL_BACKOFF) => {
+        req = request(options, (res) => {
+            let responseData = '';
+            res.on('data', chunk => (responseData += chunk));
+            res.on('aborted', () => {
+                if (reqIsDestroyed) {
+                    const err = new types_2.OTLPExporterError('Request Timeout');
+                    onError(err);
+                }
+            });
+            res.on('end', () => {
+                if (reqIsDestroyed === false) {
+                    if (res.statusCode && res.statusCode < 299) {
+                        api_1.diag.debug(`statusCode: ${res.statusCode}`, responseData);
+                        onSuccess();
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                    else if (res.statusCode &&
+                        (0, util_1.isExportRetryable)(res.statusCode) &&
+                        retries > 0) {
+                        let retryTime;
+                        minDelay = util_1.DEFAULT_EXPORT_BACKOFF_MULTIPLIER * minDelay;
+                        // retry after interval specified in Retry-After header
+                        if (res.headers['retry-after']) {
+                            retryTime = (0, util_1.parseRetryAfterToMills)(res.headers['retry-after']);
+                        }
+                        else {
+                            // exponential backoff with jitter
+                            retryTime = Math.round(Math.random() * (util_1.DEFAULT_EXPORT_MAX_BACKOFF - minDelay) +
+                                minDelay);
+                        }
+                        retryTimer = setTimeout(() => {
+                            sendWithRetry(retries - 1, minDelay);
+                        }, retryTime);
+                    }
+                    else {
+                        const error = new types_2.OTLPExporterError(res.statusMessage, res.statusCode, responseData);
+                        onError(error);
+                        // clear all timers since request was completed and promise was resolved
+                        clearTimeout(exporterTimer);
+                        clearTimeout(retryTimer);
+                    }
+                }
+            });
+        });
+        req.on('error', (error) => {
             if (reqIsDestroyed) {
+                const err = new types_2.OTLPExporterError('Request Timeout', error.code);
+                onError(err);
+            }
+            else {
+                onError(error);
+            }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
+        });
+        req.on('abort', () => {
+            if (reqIsDestroyed) {
                 const err = new types_2.OTLPExporterError('Request Timeout');
                 onError(err);
             }
+            clearTimeout(exporterTimer);
+            clearTimeout(retryTimer);
         });
-        res.on('end', () => {
-            if (!reqIsDestroyed) {
-                if (res.statusCode && res.statusCode < 299) {
-                    api_1.diag.debug(`statusCode: ${res.statusCode}`, responseData);
-                    onSuccess();
-                }
-                else {
-                    const error = new types_2.OTLPExporterError(res.statusMessage, res.statusCode, responseData);
-                    onError(error);
-                }
-                clearTimeout(exporterTimer);
+        switch (collector.compression) {
+            case types_1.CompressionAlgorithm.GZIP: {
+                req.setHeader('Content-Encoding', 'gzip');
+                const dataStream = readableFromBuffer(data);
+                dataStream
+                    .on('error', onError)
+                    .pipe(zlib.createGzip())
+                    .on('error', onError)
+                    .pipe(req);
+                break;
             }
-        });
-    });
-    req.on('error', (error) => {
-        if (reqIsDestroyed) {
-            const err = new types_2.OTLPExporterError('Request Timeout', error.code);
-            onError(err);
+            default:
+                req.end(data);
+                break;
         }
-        else {
-            clearTimeout(exporterTimer);
-            onError(error);
-        }
-    });
-    switch (collector.compression) {
-        case types_1.CompressionAlgorithm.GZIP: {
-            req.setHeader('Content-Encoding', 'gzip');
-            const dataStream = readableFromBuffer(data);
-            dataStream
-                .on('error', onError)
-                .pipe(zlib.createGzip())
-                .on('error', onError)
-                .pipe(req);
-            break;
-        }
-        default:
-            req.end(data);
-            break;
-    }
+    };
+    sendWithRetry();
 }
@@ -112,0 +152,0 @@ exports.sendWithHttp = sendWithHttp;

build/src/util.d.ts

@@ -0,1 +1,5 @@
+export declare const DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+export declare const DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+export declare const DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+export declare const DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -26,2 +30,4 @@ * Parses headers from config leaving only those that have defined values
 export declare function invalidTimeout(timeout: number, defaultTimeout: number): number;
+export declare function isExportRetryable(statusCode: number): boolean;
+export declare function parseRetryAfterToMills(retryAfter?: string | null): number;
 //# sourceMappingURL=util.d.ts.map

build/src/util.js

@@ -18,6 +18,10 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invalidTimeout = exports.configureExporterTimeout = exports.appendRootPathToUrlIfNeeded = exports.appendResourcePathToUrl = exports.parseHeaders = void 0;
+exports.parseRetryAfterToMills = exports.isExportRetryable = exports.invalidTimeout = exports.configureExporterTimeout = exports.appendRootPathToUrlIfNeeded = exports.appendResourcePathToUrl = exports.parseHeaders = exports.DEFAULT_EXPORT_BACKOFF_MULTIPLIER = exports.DEFAULT_EXPORT_MAX_BACKOFF = exports.DEFAULT_EXPORT_INITIAL_BACKOFF = exports.DEFAULT_EXPORT_MAX_ATTEMPTS = void 0;
 const api_1 = require("@opentelemetry/api");
 const core_1 = require("@opentelemetry/core");
 const DEFAULT_TRACE_TIMEOUT = 10000;
+exports.DEFAULT_EXPORT_MAX_ATTEMPTS = 5;
+exports.DEFAULT_EXPORT_INITIAL_BACKOFF = 1000;
+exports.DEFAULT_EXPORT_MAX_BACKOFF = 5000;
+exports.DEFAULT_EXPORT_BACKOFF_MULTIPLIER = 1.5;
 /**
@@ -107,2 +111,23 @@ * Parses headers from config leaving only those that have defined values
 exports.invalidTimeout = invalidTimeout;
+function isExportRetryable(statusCode) {
+    const retryCodes = [429, 502, 503, 504];
+    return retryCodes.includes(statusCode);
+}
+exports.isExportRetryable = isExportRetryable;
+function parseRetryAfterToMills(retryAfter) {
+    if (retryAfter == null) {
+        return -1;
+    }
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (Number.isInteger(seconds)) {
+        return seconds > 0 ? seconds * 1000 : -1;
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives
+    const delay = new Date(retryAfter).getTime() - Date.now();
+    if (delay >= 0) {
+        return delay;
+    }
+    return 0;
+}
+exports.parseRetryAfterToMills = parseRetryAfterToMills;
 //# sourceMappingURL=util.js.map

build/src/version.d.ts

@@ -1,2 +0,2 @@
-export declare const VERSION = "0.35.1";
+export declare const VERSION = "0.36.0";
 //# sourceMappingURL=version.d.ts.map

build/src/version.js

@@ -20,3 +20,3 @@ "use strict";
 // this is autogenerated file, see scripts/version-update.js
-exports.VERSION = '0.35.1';
+exports.VERSION = '0.36.0';
 //# sourceMappingURL=version.js.map

package.json

 {
   "name": "@opentelemetry/otlp-exporter-base",
-  "version": "0.35.1",
+  "version": "0.36.0",
   "description": "OpenTelemetry OTLP Exporter base (for internal use only)",
@@ -64,6 +64,6 @@ "main": "build/src/index.js",
   "dependencies": {
-    "@opentelemetry/core": "1.9.1"
+    "@opentelemetry/core": "1.10.0"
   },
   "devDependencies": {
-    "@opentelemetry/api": "^1.0.0",
+    "@opentelemetry/api": "1.4.1",
     "@types/mocha": "10.0.0",
@@ -87,3 +87,3 @@ "@types/node": "18.6.5",
   "sideEffects": false,
-  "gitHead": "279458e7ddf16f7ddca5fe60c78672e05fafce66"
+  "gitHead": "56e6b1bb890f844b8963a146780d0b9cfa8abd0d"
 }

No alert changes

Improved metrics

Total package byte prevSize

297353

increased by16.47%

Lines of code

3102

increased by12.31%

Dependency changes

• + Added@opentelemetry/core@1.10.0(transitive)

• + Added@opentelemetry/semantic-conventions@1.10.0(transitive)

• - Removed@opentelemetry/core@1.9.1(transitive)

• - Removed@opentelemetry/semantic-conventions@1.9.1(transitive)

• Updated@opentelemetry/core@1.10.0