Add support for OTEL_BSP_EXPORT_* environmental variables

src/OpenTelemetry/BatchExportProcessorOptions.cs

@@ -14,11 +14,57 @@
 // limitations under the License.
 // </copyright>
 
+using System;
+using System.Security;
+using OpenTelemetry.Internal;
+
 namespace OpenTelemetry
 {
     public class BatchExportProcessorOptions<T>
         where T : class
     {
+        internal const string MaxQueueSizeEnvVarKey = "OTEL_BSP_MAX_QUEUE_SIZE";
+
+        internal const string MaxExportBatchSizeEnvVarKey = "OTEL_BSP_MAX_EXPORT_BATCH_SIZE";
+
+        internal const string ExporterTimeoutEnvVarKey = "OTEL_BSP_EXPORT_TIMEOUT";
+
+        internal const string ScheduledDelayEnvVarKey = "OTEL_BSP_SCHEDULE_DELAY";
+
+        public BatchExportProcessorOptions()
+        {
+            try
+            {
+                int value;
+
+                if (TryLoadEnvVarInt(BatchExportProcessorOptions<T>.ExporterTimeoutEnvVarKey, out value))
+                {
+                    this.ExporterTimeoutMilliseconds = value;
+                }
+
+                if (TryLoadEnvVarInt(BatchExportProcessorOptions<T>.MaxExportBatchSizeEnvVarKey, out value))
+                {
+                    this.MaxExportBatchSize = value;
+                }
+
+                if (TryLoadEnvVarInt(BatchExportProcessorOptions<T>.MaxQueueSizeEnvVarKey, out value))
+                {
+                    this.MaxQueueSize = value;
+                }
+
+                if (TryLoadEnvVarInt(BatchExportProcessorOptions<T>.ScheduledDelayEnvVarKey, out value))
+                {
+                    this.ScheduledDelayMilliseconds = value;
+                }
+            }
+            catch (SecurityException ex)
+            {
+                // The caller does not have the required permission to
+                // retrieve the value of an environment variable from the current process.
+                OpenTelemetrySdkEventSource.Log.MissingPermissionsToReadEnvironmentVariable(ex);
+            }
+        }
+
         /// <summary>
         /// Gets or sets the maximum queue size. The queue drops the data if the maximum size is reached. The default value is 2048.
         /// </summary>
@@ -38,5 +84,24 @@ public class BatchExportProcessorOptions<T>
         /// Gets or sets the maximum batch size of every export. It must be smaller or equal to MaxQueueLength. The default value is 512.
         /// </summary>
         public int MaxExportBatchSize { get; set; } = BatchExportProcessor<T>.DefaultMaxExportBatchSize;
+
+        private static bool TryLoadEnvVarInt(string envVarKey, out int result)
+        {
+            result = 0;
+            string value = Environment.GetEnvironmentVariable(envVarKey);
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            if (!int.TryParse(value, out var parsedValue))
+            {
+                OpenTelemetrySdkEventSource.Log.FailedToParseEnvironmentVariable(envVarKey, value);
+                return false;
+            }
+
+            result = parsedValue;
+            return true;
+        }
     }
 }

src/OpenTelemetry/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+* The `BatchExportProcessorOptions` defaults can be overridden using
+  `OTEL_BSP_SCHEDULE_DELAY`, `OTEL_BSP_EXPORT_TIMEOUT`,
+  `OTEL_BSP_MAX_QUEUE_SIZE`, `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
+  envionmental variables as defined in the
+  [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.5.0/specification/sdk-environment-variables.md#batch-span-processor).
+  ([#2219](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2219))
+
 * Removes upper constraint for Microsoft.Extensions.Logging
   dependencies. ([#2179](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2179))
 

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -21,6 +21,7 @@
 #endif
 using System.Diagnostics;
 using System.Diagnostics.Tracing;
+using System.Security;
 
 namespace OpenTelemetry.Internal
 {
@@ -125,6 +126,15 @@ public void TracerProviderException(string evnt, Exception ex)
             }
         }
 
+        [NonEvent]
+        public void MissingPermissionsToReadEnvironmentVariable(SecurityException ex)
+        {
+            if (this.IsEnabled(EventLevel.Warning, EventKeywords.All))
+            {
+                this.MissingPermissionsToReadEnvironmentVariable(ex.ToInvariantString());
+            }
+        }
+
         [Event(1, Message = "Span processor queue size reached maximum. Throttling spans.", Level = EventLevel.Warning)]
         public void SpanProcessorQueueIsExhausted()
         {
@@ -287,6 +297,18 @@ public void TracerProviderException(string evnt, string ex)
             this.WriteEvent(28, evnt, ex);
         }
 
+        [Event(29, Message = "Failed to parse environment variable: '{0}', value: '{1}'.", Level = EventLevel.Warning)]
+        public void FailedToParseEnvironmentVariable(string name, string value)
+        {
+            this.WriteEvent(29, name, value);
+        }
+
+        [Event(30, Message = "Missing permissions to read environment variable: '{0}'", Level = EventLevel.Warning)]
+        public void MissingPermissionsToReadEnvironmentVariable(string exception)
+        {
+            this.WriteEvent(30, exception);
+        }
+
 #if DEBUG
         public class OpenTelemetryEventListener : EventListener
         {

src/OpenTelemetry/README.md

@@ -200,10 +200,24 @@ purposes, the SDK provides the following built-in processors:
 * [BatchExportProcessor<T>](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#batching-processor)
   : This is an exporting processor which batches the telemetry before sending to
   the configured exporter.
+
+  The following environment variables can be used to override the default
+  values of the `BatchExportProcessorOptions<T>`.
+
+  <!-- markdownlint-disable MD013 -->
+  | Environment variable             | `BatchExportProcessorOptions<T>` property |
+  | -------------------------------- | ---------------------------------------------- |
+  | `OTEL_BSP_SCHEDULE_DELAY`        | `ScheduledDelayMilliseconds`                   |
+  | `OTEL_BSP_EXPORT_TIMEOUT`        | `ExporterTimeoutMilliseconds`                  |
+  | `OTEL_BSP_MAX_QUEUE_SIZE`        | `MaxQueueSize`                                 |
+  | `OTEL_BSP_MAX_EXPORT_BATCH_SIZE` | `MaxExportBatchSizeEnvVarKey`                  |
+  <!-- markdownlint-enable MD013 -->
+
 * [CompositeProcessor&lt;T&gt;](../../src/OpenTelemetry/CompositeProcessor.cs)
   : This is a processor which can be composed from multiple processors. This is
   typically used to construct multiple processing pipelines, each ending with
   its own exporter.
+
 * [SimpleExportProcessor&lt;T&gt;](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#simple-processor)
   : This is an exporting processor which passes telemetry to the configured
   exporter without any batching.

test/OpenTelemetry.Tests/Trace/BatchExportProcessorOptionsTest.cs

@@ -0,0 +1,103 @@
+// <copyright file="BatchExportProcessorOptionsTest.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using Xunit;
+
+using Options = OpenTelemetry.BatchExportProcessorOptions<object>;
+
+namespace OpenTelemetry.Trace.Tests
+{
+    public class BatchExportProcessorOptionsTest : IDisposable
+    {
+        public BatchExportProcessorOptionsTest()
+        {
+            this.ClearEnvVars();
+        }
+
+        public void Dispose()
+        {
+            this.ClearEnvVars();
+        }
+
+        [Fact]
+        public void BatchExportProcessorOptions_Defaults()
+        {
+            var options = new Options();
+
+            Assert.Equal(30000, options.ExporterTimeoutMilliseconds);
+            Assert.Equal(512, options.MaxExportBatchSize);
+            Assert.Equal(2048, options.MaxQueueSize);
+            Assert.Equal(5000, options.ScheduledDelayMilliseconds);
+        }
+
+        [Fact]
+        public void BatchExportProcessorOptions_EnvironmentVariableOverride()
+        {
+            Environment.SetEnvironmentVariable(Options.ExporterTimeoutEnvVarKey, "1");
+            Environment.SetEnvironmentVariable(Options.MaxExportBatchSizeEnvVarKey, "2");
+            Environment.SetEnvironmentVariable(Options.MaxQueueSizeEnvVarKey, "3");
+            Environment.SetEnvironmentVariable(Options.ScheduledDelayEnvVarKey, "4");
+
+            var options = new BatchExportProcessorOptions<object>();
+
+            Assert.Equal(1, options.ExporterTimeoutMilliseconds);
+            Assert.Equal(2, options.MaxExportBatchSize);
+            Assert.Equal(3, options.MaxQueueSize);
+            Assert.Equal(4, options.ScheduledDelayMilliseconds);
+        }
+
+        [Fact]
+        public void BatchExportProcessorOptions_InvalidPortEnvironmentVariableOverride()
+        {
+            Environment.SetEnvironmentVariable(BatchExportProcessorOptions<object>.ExporterTimeoutEnvVarKey, "invalid");
+
+            var options = new Options();
+
+            Assert.Equal(30000, options.ExporterTimeoutMilliseconds); // use default
+        }
+
+        [Fact]
+        public void BatchExportProcessorOptions_SetterOverridesEnvironmentVariable()
+        {
+            Environment.SetEnvironmentVariable(BatchExportProcessorOptions<object>.ExporterTimeoutEnvVarKey, "123");
+
+            var options = new Options
+            {
+                ExporterTimeoutMilliseconds = 89000,
+            };
+
+            Assert.Equal(89000, options.ExporterTimeoutMilliseconds);
+        }
+
+        [Fact]
+        public void BatchExportProcessorOptions_EnvironmentVariableNames()
+        {
+            Assert.Equal("OTEL_BSP_EXPORT_TIMEOUT", Options.ExporterTimeoutEnvVarKey);
+            Assert.Equal("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", Options.MaxExportBatchSizeEnvVarKey);
+            Assert.Equal("OTEL_BSP_MAX_QUEUE_SIZE", Options.MaxQueueSizeEnvVarKey);
+            Assert.Equal("OTEL_BSP_SCHEDULE_DELAY", Options.ScheduledDelayEnvVarKey);
+        }
+
+        private void ClearEnvVars()
+        {
+            Environment.SetEnvironmentVariable(Options.ExporterTimeoutEnvVarKey, null);
+            Environment.SetEnvironmentVariable(Options.MaxExportBatchSizeEnvVarKey, null);
+            Environment.SetEnvironmentVariable(Options.MaxQueueSizeEnvVarKey, null);
+            Environment.SetEnvironmentVariable(Options.ScheduledDelayEnvVarKey, null);
+        }
+    }
+}