feat: batch span processor environment config (#1755)

Co-authored-by: Daniel Dyla <[email protected]>

Author: mwear

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

@@ -28,13 +28,17 @@ export interface ENVIRONMENT {
   OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT?: number;
   OTEL_SPAN_EVENT_COUNT_LIMIT?: number;
   OTEL_SPAN_LINK_COUNT_LIMIT?: number;
+  OTEL_BSP_MAX_BATCH_SIZE?: number;
+  OTEL_BSP_SCHEDULE_DELAY_MILLIS?: number;
 }
 
 const ENVIRONMENT_NUMBERS: Partial<keyof ENVIRONMENT>[] = [
   'OTEL_SAMPLING_PROBABILITY',
   'OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT',
   'OTEL_SPAN_EVENT_COUNT_LIMIT',
   'OTEL_SPAN_LINK_COUNT_LIMIT',
+  'OTEL_BSP_MAX_BATCH_SIZE',
+  'OTEL_BSP_SCHEDULE_DELAY_MILLIS',
 ];
 
 /**
@@ -47,6 +51,8 @@ export const DEFAULT_ENVIRONMENT: Required<ENVIRONMENT> = {
   OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: 1000,
   OTEL_SPAN_EVENT_COUNT_LIMIT: 1000,
   OTEL_SPAN_LINK_COUNT_LIMIT: 1000,
+  OTEL_BSP_MAX_BATCH_SIZE: 512,
+  OTEL_BSP_SCHEDULE_DELAY_MILLIS: 5000,
 };
 
 /**

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

@@ -80,6 +80,8 @@ describe('environment', () => {
         OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: 10,
         OTEL_SPAN_EVENT_COUNT_LIMIT: 20,
         OTEL_SPAN_LINK_COUNT_LIMIT: 30,
+        OTEL_BSP_MAX_BATCH_SIZE: 40,
+        OTEL_BSP_SCHEDULE_DELAY_MILLIS: 50,
       });
       const env = getEnv();
       assert.strictEqual(env.OTEL_NO_PATCH_MODULES, 'a,b,c');
@@ -88,6 +90,8 @@ describe('environment', () => {
       assert.strictEqual(env.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, 10);
       assert.strictEqual(env.OTEL_SPAN_EVENT_COUNT_LIMIT, 20);
       assert.strictEqual(env.OTEL_SPAN_LINK_COUNT_LIMIT, 30);
+      assert.strictEqual(env.OTEL_BSP_MAX_BATCH_SIZE, 40);
+      assert.strictEqual(env.OTEL_BSP_SCHEDULE_DELAY_MILLIS, 50);
     });
 
     it('should match invalid values to closest valid equivalent', () => {

packages/opentelemetry-tracing/src/export/BatchSpanProcessor.ts

@@ -19,16 +19,14 @@ import {
   ExportResultCode,
   globalErrorHandler,
   unrefTimer,
+  getEnv,
 } from '@opentelemetry/core';
 import { Span } from '../Span';
 import { SpanProcessor } from '../SpanProcessor';
 import { BufferConfig } from '../types';
 import { ReadableSpan } from './ReadableSpan';
 import { SpanExporter } from './SpanExporter';
 
-const DEFAULT_BUFFER_SIZE = 100;
-const DEFAULT_BUFFER_TIMEOUT_MS = 20_000;
-
 /**
  * Implementation of the {@link SpanProcessor} that batches spans exported by
  * the SDK then pushes them to the exporter pipeline.
@@ -43,12 +41,15 @@ export class BatchSpanProcessor implements SpanProcessor {
   private _shuttingDownPromise: Promise<void> = Promise.resolve();
 
   constructor(private readonly _exporter: SpanExporter, config?: BufferConfig) {
+    const env = getEnv();
     this._bufferSize =
-      config && config.bufferSize ? config.bufferSize : DEFAULT_BUFFER_SIZE;
+      config && config.bufferSize
+        ? config.bufferSize
+        : env.OTEL_BSP_MAX_BATCH_SIZE;
     this._bufferTimeout =
       config && typeof config.bufferTimeout === 'number'
         ? config.bufferTimeout
-        : DEFAULT_BUFFER_TIMEOUT_MS;
+        : env.OTEL_BSP_SCHEDULE_DELAY_MILLIS;
   }
 
   forceFlush(): Promise<void> {

packages/opentelemetry-tracing/test/export/BatchSpanProcessor.test.ts

@@ -74,6 +74,32 @@ describe('BatchSpanProcessor', () => {
       assert.ok(processor instanceof BatchSpanProcessor);
       processor.shutdown();
     });
+
+    it('should read defaults from environment', () => {
+      const bspConfig = {
+        OTEL_BSP_MAX_BATCH_SIZE: 256,
+        OTEL_BSP_SCHEDULE_DELAY_MILLIS: 2500,
+      };
+
+      let env: Record<string, any>;
+      if (typeof process === 'undefined') {
+        env = (window as unknown) as Record<string, any>;
+      } else {
+        env = process.env as Record<string, any>;
+      }
+
+      Object.entries(bspConfig).forEach(([k, v]) => {
+        env[k] = v;
+      });
+
+      const processor = new BatchSpanProcessor(exporter);
+      assert.ok(processor instanceof BatchSpanProcessor);
+      assert.strictEqual(processor['_bufferSize'], 256);
+      assert.strictEqual(processor['_bufferTimeout'], 2500);
+      processor.shutdown();
+
+      Object.keys(bspConfig).forEach(k => delete env[k]);
+    });
   });
 
   describe('.onStart/.onEnd/.shutdown', () => {