feat(otlp-exporter-base): add retries

experimental/packages/exporter-trace-otlp-http/test/browser/CollectorTraceExporter.test.ts

@@ -599,3 +599,50 @@ describe('when configuring via environment', () => {
     envSource.OTEL_EXPORTER_OTLP_HEADERS = '';
   });
 });
+
+describe('export with retry - real http request destroyed', () => {
+  let server: any;
+  let collectorTraceExporter: OTLPTraceExporter;
+  let collectorExporterConfig: OTLPExporterConfigBase;
+  let spans: ReadableSpan[];
+
+  beforeEach(() => {
+    server = sinon.fakeServer.create({
+      autoRespond: true
+    });
+    collectorExporterConfig = {
+      timeoutMillis: 1500
+    };
+  });
+
+  afterEach(() => {
+    server.restore();
+  });
+
+  describe('when "sendBeacon" is NOT available', () => {
+    beforeEach(() => {
+      (window.navigator as any).sendBeacon = false;
+      collectorTraceExporter = new OTLPTraceExporter(collectorExporterConfig);
+    });
+
+    it('should log the timeout request error message', done => {
+      spans = [];
+      spans.push(Object.assign({}, mockedReadableSpan));
+
+      let retry = 0;
+      server.respondWith('http://localhost:4318/v1/traces', function (xhr: any, id: any) {
+        retry++;
+        xhr.respond(502);
+      });
+
+      collectorTraceExporter.export(spans, result => {
+        assert.strictEqual(result.code, core.ExportResultCode.FAILED);
+        const error = result.error as OTLPExporterError;
+        assert.ok(error !== undefined);
+        assert.strictEqual(error.message, 'Request Timeout');
+        assert.strictEqual(retry, 2);
+        done();
+      });
+    }).timeout(3000);
+  });
+});

experimental/packages/exporter-trace-otlp-http/test/node/CollectorTraceExporter.test.ts

@@ -554,37 +554,41 @@ describe('export - real http request destroyed before response received', () =>
   });
 });
 
-describe('export - real http request destroyed after response received', () => {
+describe('export with retry - real http request destroyed after response received', () => {
   let collectorExporter: OTLPTraceExporter;
   let collectorExporterConfig: OTLPExporterNodeConfigBase;
   let spans: ReadableSpan[];
+  let retries = 0;
 
   const server = http.createServer((_, res) => {
-    res.write('writing something');
+    retries++;
+    if (retries >= 2) {
+      res.statusCode = 200;
+    } else {
+      res.statusCode = 502;
+    }
+    res.end();
   });
   before(done => {
     server.listen(8081, done);
   });
-  after(done => {
+  after(function (done) {
     server.close(done);
   });
   it('should log the timeout request error message', done => {
     collectorExporterConfig = {
       url: 'http://localhost:8081',
-      timeoutMillis: 300,
+      timeoutMillis: 1500,
     };
     collectorExporter = new OTLPTraceExporter(collectorExporterConfig);
     spans = [];
     spans.push(Object.assign({}, mockedReadableSpan));
 
-    setTimeout(() => {
-      collectorExporter.export(spans, result => {
-        assert.strictEqual(result.code, core.ExportResultCode.FAILED);
-        const error = result.error as OTLPExporterError;
-        assert.ok(error !== undefined);
-        assert.strictEqual(error.message, 'Request Timeout');
-        done();
-      });
-    }, 0);
-  });
+    collectorExporter.export(spans, result => {
+      assert.strictEqual(result.code, core.ExportResultCode.SUCCESS);
+      assert.strictEqual(retries, 2);
+      done();
+    });
+  }).timeout(3000);
 });
+

experimental/packages/otlp-exporter-base/src/platform/browser/util.ts

@@ -15,6 +15,12 @@
  */
 import { diag } from '@opentelemetry/api';
 import { OTLPExporterError } from '../../types';
+import {
+  DEFAULT_EXPORT_MAX_ATTEMPTS,
+  DEFAULT_EXPORT_INITIAL_BACKOFF,
+  DEFAULT_EXPORT_BACKOFF_MULTIPLIER,
+  isExportRetryable
+} from '../../util';
 
 /**
  * Send metrics/spans using browser navigator.sendBeacon
@@ -60,48 +66,86 @@ export function sendWithXhr(
   onError: (error: OTLPExporterError) => void
 ): void {
   let reqIsDestroyed: boolean;
+  let retryTimer: ReturnType<typeof setTimeout>;
+  let xhr: XMLHttpRequest;
 
   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 sendWithRetry = (retries = DEFAULT_EXPORT_MAX_ATTEMPTS, backoffMillis = DEFAULT_EXPORT_INITIAL_BACKOFF) => {
+    xhr = new XMLHttpRequest();
+    xhr.open('POST', url);
 
-  const defaultHeaders = {
-    'Accept': 'application/json',
-    'Content-Type': 'application/json',
-  };
+    const defaultHeaders = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+    };
 
-  Object.entries({
-    ...defaultHeaders,
-    ...headers,
-  }).forEach(([k, v]) => {
-    xhr.setRequestHeader(k, v);
-  });
+    Object.entries({
+      ...defaultHeaders,
+      ...headers,
+    }).forEach(([k, v]) => {
+      xhr.setRequestHeader(k, v);
+    });
 
-  xhr.send(body);
+    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();
-      } else if (reqIsDestroyed) {
-        const error = new OTLPExporterError(
-          'Request Timeout', xhr.status
+    xhr.onreadystatechange = () => {
+      if (xhr.readyState === XMLHttpRequest.DONE && reqIsDestroyed === undefined) {
+        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) {
+          retryTimer = setTimeout(() => {
+            sendWithRetry(retries - 1, backoffMillis * DEFAULT_EXPORT_BACKOFF_MULTIPLIER);
+          }, backoffMillis);
+        } else {
+          const error = new OTLPExporterError(
+            `Failed to export with XHR (status: ${xhr.status})`,
+            xhr.status
+          );
+          onError(error);
+          clearTimeout(exporterTimer);
+          clearTimeout(retryTimer);
+        }
+      }
+    };
+
+    xhr.onabort = () => {
+      if (reqIsDestroyed) {
+        const err = new OTLPExporterError(
+          'Request Timeout'
         );
-        onError(error);
-      } else {
-        const error = new OTLPExporterError(
-          `Failed to export with XHR (status: ${xhr.status})`,
-          xhr.status
+        onError(err);
+      }
+      clearTimeout(exporterTimer);
+      clearTimeout(retryTimer);
+    };
+
+    xhr.onerror = () => {
+      if (reqIsDestroyed) {
+        const err = new OTLPExporterError(
+          'Request Timeout'
         );
-        clearTimeout(exporterTimer);
-        onError(error);
+        onError(err);
       }
-    }
+      clearTimeout(exporterTimer);
+      clearTimeout(retryTimer);
+    };
   };
+
+  sendWithRetry();
 }