feat(otlp-exporter): add timeout env var

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

@@ -107,6 +107,31 @@ 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, 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
+  };
+  ```
+
+  > 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
@@ -115,9 +140,9 @@ Note, that this will only work if TLS is also configured on the server.
 
 ## 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
 

packages/exporter-trace-otlp-grpc/src/types.ts

@@ -34,6 +34,7 @@ export interface ServiceClient extends grpc.Client {
   export: (
     request: any,
     metadata: grpc.Metadata,
+    options: object,
     callback: Function
   ) => {};
 }

packages/exporter-trace-otlp-grpc/src/util.ts

@@ -84,10 +84,12 @@ export function send<ExportItem, ServiceRequest>(
 ): void {
   if (collector.serviceClient) {
     const serviceRequest = collector.convert(objects);
+    const deadline = new Date().setSeconds(new Date().getSeconds() + (collector._timeoutMillis / 1000));
 
     collector.serviceClient.export(
       serviceRequest,
       collector.metadata || new grpc.Metadata(),
+      {deadline: deadline},
       (err: otlpTypes.ExportServiceError) => {
         if (err) {
           diag.error('Service request', serviceRequest);

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

@@ -36,6 +36,8 @@ import {
   mockedReadableSpan,
 } from './traceHelper';
 
+import * as core from '@opentelemetry/core';
+
 const traceServiceProtoPath =
   'opentelemetry/proto/collector/trace/v1/trace_service.proto';
 const includeDirs = [path.resolve(__dirname, '../protos')];
@@ -197,6 +199,33 @@ const testCollectorExporter = (params: TestParams) =>
           done();
         }, 200);
       });
+      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);
+      });
     });
   });
 

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

@@ -106,6 +106,31 @@ OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://metric-service:4317/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
+  };
+  ```
+
+  > 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
@@ -114,9 +139,9 @@ For more details, see [OpenTelemetry Specification on Protocol Exporter][opentel
 
 ## 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
 

packages/exporter-trace-otlp-http/src/OTLPExporterBase.ts

@@ -21,6 +21,7 @@ import {
   OTLPExporterConfigBase,
   ExportServiceError,
 } from './types';
+import { configureExporterTimeout } from './util';
 
 /**
  * Collector Exporter abstract base class
@@ -36,6 +37,7 @@ export abstract class OTLPExporterBase<
   protected _concurrencyLimit: number;
   protected _sendingPromises: Promise<unknown>[] = [];
   protected _shutdownOnce: BindOnceFuture<void>;
+  public readonly _timeoutMillis: number;
 
   /**
    * @param config
@@ -56,6 +58,8 @@ export abstract class OTLPExporterBase<
         ? config.concurrencyLimit
         : Infinity;
 
+    this._timeoutMillis = configureExporterTimeout(config.timeoutMillis);
+
     // platform dependent
     this.onInit(config);
   }

packages/exporter-trace-otlp-http/src/platform/browser/OTLPExporterBrowserBase.ts

@@ -78,7 +78,7 @@ export abstract class OTLPExporterBrowserBase<
 
     const promise = new Promise<void>((resolve, reject) => {
       if (this._useXHR) {
-        sendWithXhr(body, this.url, this._headers, resolve, reject);
+        sendWithXhr(body, this.url, this._headers, this._timeoutMillis, resolve, reject);
       } else {
         sendWithBeacon(body, this.url, { type: 'application/json' }, resolve, reject);
       }

packages/exporter-trace-otlp-http/src/platform/browser/util.ts

@@ -51,9 +51,17 @@ export function sendWithXhr(
   body: string,
   url: string,
   headers: Record<string, string>,
+  exporterTimeout: number,
   onSuccess: () => void,
   onError: (error: otlpTypes.OTLPExporterError) => void
 ): void {
+  let reqIsDestroyed: boolean;
+
+  const exporterTimer = setTimeout(() => {
+    reqIsDestroyed = true;
+    xhr.abort();
+  }, exporterTimeout);
+
   const xhr = new XMLHttpRequest();
   xhr.open('POST', url);
 
@@ -74,14 +82,20 @@ export function sendWithXhr(
   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 otlpTypes.OTLPExporterError(
+          'Request Timeout', xhr.status
+        );
+        onError(error);
       } else {
         const error = new otlpTypes.OTLPExporterError(
           `Failed to export with XHR (status: ${xhr.status})`,
           xhr.status
         );
-
+        clearTimeout(exporterTimer);
         onError(error);
       }
     }

packages/exporter-trace-otlp-http/src/platform/node/util.ts

@@ -42,7 +42,14 @@ export function sendWithHttp<ExportItem, ServiceRequest>(
   onSuccess: () => void,
   onError: (error: otlpTypes.OTLPExporterError) => void
 ): void {
+  const exporterTimeout = collector._timeoutMillis;
   const parsedUrl = new url.URL(collector.url);
+  let reqIsDestroyed: boolean;
+
+  const exporterTimer = setTimeout(() => {
+    reqIsDestroyed = true;
+    req.destroy();
+  }, exporterTimeout);
 
   const options: http.RequestOptions | https.RequestOptions = {
     hostname: parsedUrl.hostname,
@@ -65,21 +72,30 @@ export function sendWithHttp<ExportItem, ServiceRequest>(
     res.on('end', () => {
       if (res.statusCode && res.statusCode < 299) {
         diag.debug(`statusCode: ${res.statusCode}`, responseData);
+        clearTimeout(exporterTimer);
         onSuccess();
       } else {
         const error = new otlpTypes.OTLPExporterError(
           res.statusMessage,
           res.statusCode,
           responseData
         );
+        clearTimeout(exporterTimer);
         onError(error);
       }
     });
   });
 
-
-  req.on('error', (error: Error) => {
-    onError(error);
+  req.on('error', (error: Error | any) => {
+    if (reqIsDestroyed) {
+      const err = new otlpTypes.OTLPExporterError(
+        'Request Timeout', error.code
+      );
+      onError(err);
+    } else {
+      clearTimeout(exporterTimer);
+      onError(error);
+    }
   });
 
   switch (collector.compression) {

packages/exporter-trace-otlp-http/src/types.ts

@@ -347,6 +347,9 @@ export interface OTLPExporterConfigBase {
   attributes?: SpanAttributes;
   url?: string;
   concurrencyLimit?: number;
+  /** Maximum time the OTLP exporter will wait for each batch export.
+   * The default value is 10000ms. */
+  timeoutMillis?: number;
 }
 
 /**

packages/exporter-trace-otlp-http/src/util.ts

@@ -15,6 +15,9 @@
  */
 
 import { diag } from '@opentelemetry/api';
+import { getEnv } from '@opentelemetry/core';
+
+const DEFAULT_TRACE_TIMEOUT = 10000;
 
 /**
  * Parses headers from config leaving only those that have defined values
@@ -39,3 +42,44 @@ export function appendResourcePathToUrlIfNotPresent(url: string, path: string):
 
   return url + path;
 }
+
+/**
+ * Configure exporter trace timeout value from passed in value or environment variables
+ * @param timeoutMillis
+ * @returns timeout value in milliseconds
+ */
+
+export function configureExporterTimeout(timeoutMillis: number | undefined): number {
+  if (typeof timeoutMillis === 'number') {
+    if (timeoutMillis <= 0) {
+      // OTLP exporter configured timeout - using default value of 10000ms
+      return invalidTimeout(timeoutMillis, DEFAULT_TRACE_TIMEOUT);
+    }
+    return timeoutMillis;
+  } else {
+    return getExporterTimeoutFromEnv();
+  }
+}
+
+function getExporterTimeoutFromEnv(): number {
+  const definedTimeout =
+    Number(getEnv().OTEL_EXPORTER_OTLP_TRACES_TIMEOUT ||
+    getEnv().OTEL_EXPORTER_OTLP_TIMEOUT);
+
+  if (definedTimeout) {
+    if (definedTimeout <= 0) {
+      // OTLP exporter configured timeout - using default value of 10000ms
+      return invalidTimeout(definedTimeout, DEFAULT_TRACE_TIMEOUT);
+    }
+    return definedTimeout;
+  } else {
+    return getEnv().OTEL_EXPORTER_OTLP_TRACES_TIMEOUT;
+  }
+}
+
+// OTLP exporter configured timeout - using default value of 10000ms
+function invalidTimeout(timeout: number, defaultTimeout: number): number {
+  diag.warn('Timeout must be non-negative', timeout);
+
+  return defaultTimeout;
+}