feat(otlp-exporter): add timeout env var

experimental/CHANGELOG.md

@@ -60,6 +60,7 @@ All notable changes to experimental packages in this project will be documented
 * feat(proto): add @opentelemetry/otlp-transformer package with hand-rolled transformation #2746 @dyladan
 * feat(sdk-metrics-base): shutdown and forceflush on MeterProvider #2890 @legendecas
 * feat(sdk-metrics-base): return the same meter for identical input to getMeter #2901 @legendecas
+* feat(otlp-exporter): add [OTEL_EXPORTER_OTLP_TIMEOUT](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#configuration-options) env var to otlp exporters #2738 @svetlanabrennan
 * feat(sdk-metrics-base): hoist async instrument callback invocations #2822 @legendecas
 
 ### :bug: (Bug Fix)

experimental/packages/exporter-trace-otlp-grpc/README.md

@@ -108,6 +108,27 @@ provider.register();
 
 Note, that this will only work if TLS is also configured on the server.
 
+## Exporter Timeout Configuration
+
+The OTLPTraceExporter has a timeout configuration option which is the maximum time, in milliseconds, the OTLP exporter will wait for each batch export. The default value is 10000ms.
+
++ To override the default timeout duration, provide `timeoutMillis` to OTLPTraceExporter with `collectorOptions`:
+
+  ```js
+  const collectorOptions = {
+    timeoutMillis: 15000,
+    // url is optional and can be omitted - default is localhost:4317
+    url: '<collector-hostname>:<port>',
+    metadata, // // an optional grpc.Metadata object to be sent with each request
+  };
+
+  const exporter = new OTLPTraceExporter(collectorOptions);
+  ```
+
+  > Providing `timeoutMillis` with `collectorOptions` takes precedence and overrides timeout set with environment variables.
+
+## Exporter Compression Configuration
+
 By default no compression will be used. To use compression, set it programmatically in `collectorOptions` or with environment variables. Supported compression options: `gzip` and `none`.
 
 ```js
@@ -126,13 +147,13 @@ const exporter = new OTLPTraceExporter(collectorOptions);
 
 ## Environment Variable Configuration
 
-Set compression with environment variables.
-
-```shell
-OTEL_EXPORTER_OTLP_TRACES_COMPRESSION=gzip
-```
-
- > Compression set programatically in `collectorOptions` takes precedence over compression set with environment variables. `OTEL_EXPORTER_OTLP_TRACES_COMPRESSION` takes precedence and overrides `OTEL_EXPORTER_OTLP_COMPRESSION`.
+ | Environment variable | Description |
+  |----------------------|-------------|
+  | OTEL_EXPORTER_OTLP_TRACES_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace batch. Default is 10000. |
+  | OTEL_EXPORTER_OTLP_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace and metric batch. Default is 10000. |
+  | OTEL_EXPORTER_OTLP_TRACES_COMPRESSION | The compression type to use on OTLP trace requests. Options include gzip. By default no compression will be used. |
+  | OTEL_EXPORTER_OTLP_COMPRESSION | The compression type to use on OTLP trace, metric, and log requests. Options include gzip. By default no compression will be used. |
+ > The per-signal environment variables (`OTEL_EXPORTER_OTLP_TRACES_TIMEOUT`) takes precedence and non-per-signal environment variable (`OTEL_EXPORTER_OTLP_TIMEOUT`).
 
 ## Running opentelemetry-collector locally to see the traces
 
@@ -141,9 +162,9 @@ OTEL_EXPORTER_OTLP_TRACES_COMPRESSION=gzip
 
 ## Useful links
 
-- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
-- For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
-- For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
++ For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
++ For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
++ For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
 
 ## License
 

experimental/packages/exporter-trace-otlp-grpc/test/OTLPTraceExporter.test.ts

@@ -34,6 +34,7 @@ import {
   ensureResourceIsCorrect,
   mockedReadableSpan,
 } from './traceHelper';
+import * as core from '@opentelemetry/core';
 import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base';
 import { GrpcCompressionAlgorithm } from '@opentelemetry/otlp-grpc-exporter-base';
 import { IExportTraceServiceRequest, IResourceSpans } from '@opentelemetry/otlp-transformer';
@@ -197,7 +198,34 @@ const testCollectorExporter = (params: TestParams) =>
           ensureMetadataIsCorrect(reqMetadata, params?.metadata);
 
           done();
-        }, 200);
+        }, 500);
+      });
+      it('should log deadline exceeded error', done => {
+        const credentials = params.useTLS
+          ? grpc.credentials.createSsl(
+            fs.readFileSync('./test/certs/ca.crt'),
+            fs.readFileSync('./test/certs/client.key'),
+            fs.readFileSync('./test/certs/client.crt')
+          )
+          : undefined;
+
+        const collectorExporterWithTimeout = new OTLPTraceExporter({
+          url: 'grpcs://' + address,
+          credentials,
+          metadata: params.metadata,
+          timeoutMillis: 100,
+        });
+
+        const responseSpy = sinon.spy();
+        const spans = [Object.assign({}, mockedReadableSpan)];
+        collectorExporterWithTimeout.export(spans, responseSpy);
+
+        setTimeout(() => {
+          const result = responseSpy.args[0][0] as core.ExportResult;
+          assert.strictEqual(result.code, core.ExportResultCode.FAILED);
+          assert.strictEqual(responseSpy.args[0][0].error.details, 'Deadline exceeded');
+          done();
+        }, 300);
       });
     });
     describe('export - with gzip compression', () => {

experimental/packages/exporter-trace-otlp-http/README.md

@@ -107,16 +107,48 @@ OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://metric-service:4318/v1/metrics
 
 For more details, see [OpenTelemetry Specification on Protocol Exporter][opentelemetry-spec-protocol-exporter].
 
+## Exporter Timeout Configuration
+
+The OTLPTraceExporter has a timeout configuration option which is the maximum time, in milliseconds, the OTLP exporter will wait for each batch export. The default value is 10000ms.
+
+To override the default timeout duration, use the following options:
+
++ Set with environment variables:
+
+  | Environment variable | Description |
+  |----------------------|-------------|
+  | OTEL_EXPORTER_OTLP_TRACES_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace batch. Default is 10000. |
+  | OTEL_EXPORTER_OTLP_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace and metric batch. Default is 10000. |
+
+  > `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT` takes precedence and overrides `OTEL_EXPORTER_OTLP_TIMEOUT`.
+
++ Provide `timeoutMillis` to OTLPTraceExporter with `collectorOptions`:
+
+  ```js
+  const collectorOptions = {
+    timeoutMillis: 15000,
+    url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/traces
+    headers: {
+      foo: 'bar'
+    }, // an optional object containing custom headers to be sent with each request will only work with http
+    concurrencyLimit: 10, // an optional limit on pending requests
+  };
+
+  const exporter = new OTLPTraceExporter(collectorOptions);
+  ```
+
+  > Providing `timeoutMillis` with `collectorOptions` takes precedence and overrides timeout set with environment variables.
+
 ## Running opentelemetry-collector locally to see the traces
 
 1. Go to `examples/otlp-exporter-node`
 2. Follow the instructions there to inspect traces.
 
 ## Useful links
 
-- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
-- For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
-- For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
++ For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
++ For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
++ For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
 
 ## License
 

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

@@ -14,21 +14,21 @@
  * limitations under the License.
  */
 
+import * as core from '@opentelemetry/core';
 import { diag, DiagLogger, DiagLogLevel } from '@opentelemetry/api';
 import { ExportResultCode } from '@opentelemetry/core';
 import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import * as assert from 'assert';
 import * as sinon from 'sinon';
 import { OTLPTraceExporter } from '../../src/platform/browser/index';
-
 import {
   ensureSpanIsCorrect,
   ensureExportTraceServiceRequestIsSet,
   ensureWebResourceIsCorrect,
   ensureHeadersContain,
   mockedReadableSpan,
 } from '../traceHelper';
-import { OTLPExporterConfigBase } from '@opentelemetry/otlp-exporter-base';
+import { OTLPExporterConfigBase, OTLPExporterError } from '@opentelemetry/otlp-exporter-base';
 import { IExportTraceServiceRequest } from '@opentelemetry/otlp-transformer';
 
 describe('OTLPTraceExporter - web', () => {
@@ -176,7 +176,12 @@ describe('OTLPTraceExporter - web', () => {
 
     describe('when "sendBeacon" is NOT available', () => {
       let server: any;
+      let clock: sinon.SinonFakeTimers;
       beforeEach(() => {
+        // fakeTimers is used to replace the next setTimeout which is
+        // located in sendWithXhr function called by the export method
+        clock = sinon.useFakeTimers();
+
         (window.navigator as any).sendBeacon = false;
         collectorTraceExporter = new OTLPTraceExporter(
           collectorExporterConfig
@@ -191,7 +196,7 @@ describe('OTLPTraceExporter - web', () => {
         collectorTraceExporter.export(spans, () => {
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const request = server.requests[0];
           assert.strictEqual(request.method, 'POST');
           assert.strictEqual(request.url, 'http://foo.bar.com');
@@ -211,9 +216,9 @@ describe('OTLPTraceExporter - web', () => {
           ensureWebResourceIsCorrect(resource);
 
           assert.strictEqual(stubBeacon.callCount, 0);
-
           ensureExportTraceServiceRequestIsSet(json);
 
+          clock.restore();
           done();
         });
       });
@@ -236,15 +241,15 @@ describe('OTLPTraceExporter - web', () => {
         collectorTraceExporter.export(spans, () => {
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const request = server.requests[0];
           request.respond(200);
-
           const response: any = spyLoggerDebug.args[2][0];
           assert.strictEqual(response, 'xhr success');
           assert.strictEqual(spyLoggerError.args.length, 0);
-
           assert.strictEqual(stubBeacon.callCount, 0);
+
+          clock.restore();
           done();
         });
       });
@@ -256,21 +261,24 @@ describe('OTLPTraceExporter - web', () => {
           done();
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const request = server.requests[0];
           request.respond(400);
+          clock.restore();
+          done();
         });
       });
 
       it('should send custom headers', done => {
         collectorTraceExporter.export(spans, () => {
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const request = server.requests[0];
           request.respond(200);
 
           assert.strictEqual(stubBeacon.callCount, 0);
+          clock.restore();
           done();
         });
       });
@@ -373,7 +381,12 @@ describe('OTLPTraceExporter - web', () => {
     });
 
     describe('when "sendBeacon" is available', () => {
+      let clock: sinon.SinonFakeTimers;
       beforeEach(() => {
+        // fakeTimers is used to replace the next setTimeout which is
+        // located in sendWithXhr function called by the export method
+        clock = sinon.useFakeTimers();
+
         collectorTraceExporter = new OTLPTraceExporter(
           collectorExporterConfig
         );
@@ -382,20 +395,26 @@ describe('OTLPTraceExporter - web', () => {
         collectorTraceExporter.export(spans, () => {
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const [{ requestHeaders }] = server.requests;
 
           ensureHeadersContain(requestHeaders, customHeaders);
           assert.strictEqual(stubBeacon.callCount, 0);
           assert.strictEqual(stubOpen.callCount, 0);
 
+          clock.restore();
           done();
         });
       });
     });
 
     describe('when "sendBeacon" is NOT available', () => {
+      let clock: sinon.SinonFakeTimers;
       beforeEach(() => {
+        // fakeTimers is used to replace the next setTimeout which is
+        // located in sendWithXhr function called by the export method
+        clock = sinon.useFakeTimers();
+
         (window.navigator as any).sendBeacon = false;
         collectorTraceExporter = new OTLPTraceExporter(
           collectorExporterConfig
@@ -406,13 +425,30 @@ describe('OTLPTraceExporter - web', () => {
         collectorTraceExporter.export(spans, () => {
         });
 
-        setTimeout(() => {
+        queueMicrotask(() => {
           const [{ requestHeaders }] = server.requests;
 
           ensureHeadersContain(requestHeaders, customHeaders);
           assert.strictEqual(stubBeacon.callCount, 0);
           assert.strictEqual(stubOpen.callCount, 0);
 
+          clock.restore();
+          done();
+        });
+      });
+      it('should log the timeout request error message', done => {
+        const responseSpy = sinon.spy();
+        collectorTraceExporter.export(spans, responseSpy);
+        clock.tick(10000);
+        clock.restore();
+
+        setTimeout(() => {
+          const result = responseSpy.args[0][0] as core.ExportResult;
+          assert.strictEqual(result.code, core.ExportResultCode.FAILED);
+          const error = result.error as OTLPExporterError;
+          assert.ok(error !== undefined);
+          assert.strictEqual(error.message, 'Request Timeout');
+
           done();
         });
       });