feat(otlp-exporter): add timeout env var

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

@@ -15,7 +15,7 @@
  */
 
 import { SpanAttributes, diag } from '@opentelemetry/api';
-import { ExportResult, ExportResultCode, BindOnceFuture } from '@opentelemetry/core';
+import { ExportResult, ExportResultCode, BindOnceFuture, getEnv } from '@opentelemetry/core';
 import {
   OTLPExporterError,
   OTLPExporterConfigBase,
@@ -36,6 +36,7 @@ export abstract class OTLPExporterBase<
   protected _concurrencyLimit: number;
   protected _sendingPromises: Promise<unknown>[] = [];
   protected _shutdownOnce: BindOnceFuture<void>;
+  private readonly _timeoutMillis: number;
 
   /**
    * @param config
@@ -56,6 +57,8 @@ export abstract class OTLPExporterBase<
         ? config.concurrencyLimit
         : Infinity;
 
+    this._timeoutMillis = this._configureTimeout(config.timeoutMillis);
+
     // platform dependent
     this.onInit(config);
   }
@@ -93,6 +96,11 @@ export abstract class OTLPExporterBase<
 
   private _export(items: ExportItem[]): Promise<unknown> {
     return new Promise<void>((resolve, reject) => {
+      setTimeout(() => {
+        // don't wait anymore for export
+        reject(new Error('Timeout'));
+      }, this._timeoutMillis);
+
       try {
         diag.debug('items to be sent', items);
         this.send(items, resolve, reject);
@@ -102,6 +110,26 @@ export abstract class OTLPExporterBase<
     });
   }
 
+  private _configureTimeout(timeoutMillis: number | undefined): number {
+    let defaultTimeout = getEnv().OTEL_EXPORTER_OTLP_TRACES_TIMEOUT;
+
+    if ( defaultTimeout === null) {
+      defaultTimeout = getEnv().OTEL_EXPORTER_OTLP_TIMEOUT;
+    }
+
+    return typeof timeoutMillis === 'number'
+        ? timeoutMillis < 0
+          ? this._invalidTimeout(timeoutMillis, defaultTimeout)
+          : timeoutMillis
+            : defaultTimeout;
+  }
+
+  private _invalidTimeout(timeout: number, defaultTimeout: number): number {
+    diag.warn('Timeout must be non-negative', timeout);
+
+    return defaultTimeout;
+  }
+
   /**
    * Shutdown the exporter.
    */

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/opentelemetry-core/src/utils/environment.ts

@@ -34,6 +34,8 @@ const ENVIRONMENT_NUMBERS_KEYS = [
   'OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT',
   'OTEL_SPAN_EVENT_COUNT_LIMIT',
   'OTEL_SPAN_LINK_COUNT_LIMIT',
+  'OTEL_EXPORTER_OTLP_TIMEOUT',
+  'OTEL_EXPORTER_OTLP_TRACES_TIMEOUT'
 ] as const;
 
 type ENVIRONMENT_NUMBERS = {
@@ -118,6 +120,8 @@ export const DEFAULT_ENVIRONMENT: Required<ENVIRONMENT> = {
   OTEL_EXPORTER_OTLP_HEADERS: '',
   OTEL_EXPORTER_OTLP_TRACES_HEADERS: '',
   OTEL_EXPORTER_OTLP_METRICS_HEADERS: '',
+  OTEL_EXPORTER_OTLP_TIMEOUT: 10000,
+  OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: 10000,
   OTEL_EXPORTER_ZIPKIN_ENDPOINT: 'http://localhost:9411/api/v2/spans',
   OTEL_LOG_LEVEL: DiagLogLevel.INFO,
   OTEL_NO_PATCH_MODULES: [],

packages/opentelemetry-core/test/utils/environment.test.ts

@@ -92,6 +92,8 @@ describe('environment', () => {
         OTEL_SPAN_LINK_COUNT_LIMIT: 30,
         OTEL_TRACES_SAMPLER: 'always_on',
         OTEL_TRACES_SAMPLER_ARG: '0.5',
+        OTEL_EXPORTER_OTLP_TIMEOUT: 10000,
+        OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: 10000,
       });
       const env = getEnv();
       assert.deepStrictEqual(env.OTEL_NO_PATCH_MODULES, ['a', 'b', 'c']);
@@ -126,6 +128,8 @@ describe('environment', () => {
       assert.strictEqual(env.OTEL_BSP_SCHEDULE_DELAY, 50);
       assert.strictEqual(env.OTEL_TRACES_SAMPLER, 'always_on');
       assert.strictEqual(env.OTEL_TRACES_SAMPLER_ARG, '0.5');
+      assert.strictEqual(env.OTEL_EXPORTER_OTLP_TIMEOUT, 10000);
+      assert.strictEqual(env.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT, 10000);
     });
 
     it('should parse OTEL_LOG_LEVEL despite casing', () => {