[TRACE SDK] Batch span processor options now using env variables

sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h

@@ -17,22 +17,30 @@ namespace trace
 /**
  * Struct to hold batch SpanProcessor options.
  */
-struct BatchSpanProcessorOptions
+struct OPENTELEMETRY_EXPORT BatchSpanProcessorOptions
 {
+  BatchSpanProcessorOptions();
   /**
    * The maximum buffer/queue size. After the size is reached, spans are
    * dropped.
    */
-  size_t max_queue_size = 2048;
+  size_t max_queue_size;
 
   /* The time interval between two consecutive exports. */
-  std::chrono::milliseconds schedule_delay_millis = std::chrono::milliseconds(5000);
+  std::chrono::milliseconds schedule_delay_millis;
+
+  /**
+   * The maximum time allowed to to export data
+   * It is not currently used by the SDK and the parameter is ignored
+   * TODO: Implement the parameter in BatchSpanProcessor
+   */
+  std::chrono::milliseconds export_timeout;
 
   /**
    * The maximum batch size of every export. It must be smaller or
    * equal to max_queue_size.
    */
-  size_t max_export_batch_size = 512;
+  size_t max_export_batch_size;
 };
 
 }  // namespace trace

sdk/src/trace/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(
   provider.cc
   batch_span_processor.cc
   batch_span_processor_factory.cc
+  batch_span_processor_options.cc
   simple_processor_factory.cc
   samplers/always_on_factory.cc
   samplers/always_off_factory.cc

sdk/src/trace/batch_span_processor_options.cc

@@ -0,0 +1,69 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <stddef.h>
+#include <chrono>
+#include <cstdint>
+
+#include "opentelemetry/sdk/common/env_variables.h"
+#include "opentelemetry/sdk/trace/batch_span_processor_options.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace trace
+{
+
+constexpr const char *kMaxQueueSizeEnv       = "OTEL_BSP_MAX_QUEUE_SIZE";
+constexpr const char *kScheduleDelayEnv      = "OTEL_BSP_SCHEDULE_DELAY";
+constexpr const char *kExportTimeoutEnv      = "OTEL_BSP_EXPORT_TIMEOUT";
+constexpr const char *kMaxExportBatchSizeEnv = "OTEL_BSP_MAX_EXPORT_BATCH_SIZE";
+
+const size_t kDefaultMaxQueueSize                           = 2084;
+const std::chrono::milliseconds kDefaultScheduleDelayMillis = std::chrono::milliseconds(5000);
+const std::chrono::milliseconds kDefaultExportTimeout       = std::chrono::milliseconds(3000);
+const size_t kDefaultMaxExportBatchSize                     = 512;
+
+inline size_t GetMaxQueueSizeFromEnv()
+{
+  std::uint32_t value;
+  if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxQueueSizeEnv, value))
+  {
+    return kDefaultMaxQueueSize;
+  }
+  return static_cast<size_t>(value);
+}
+
+inline std::chrono::milliseconds GetDurationFromEnv(
+    const char *env_var,
+    const std::chrono::milliseconds &default_duration)
+{
+  std::chrono::system_clock::duration duration{0};
+  if (!opentelemetry::sdk::common::GetDurationEnvironmentVariable(env_var, duration))
+  {
+    return default_duration;
+  }
+  return std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+}
+
+inline size_t GetMaxExportBatchSizeFromEnv()
+{
+  std::uint32_t value;
+  if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxExportBatchSizeEnv, value))
+  {
+    return kDefaultMaxExportBatchSize;
+  }
+  return static_cast<size_t>(value);
+}
+
+BatchSpanProcessorOptions::BatchSpanProcessorOptions()
+    : max_queue_size(GetMaxQueueSizeFromEnv()),
+      schedule_delay_millis(GetDurationFromEnv(kScheduleDelayEnv, kDefaultScheduleDelayMillis)),
+      export_timeout(GetDurationFromEnv(kExportTimeoutEnv, kDefaultExportTimeout)),
+      max_export_batch_size(GetMaxExportBatchSizeFromEnv())
+{}
+
+}  // namespace trace
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/test/trace/batch_span_processor_test.cc

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <gtest/gtest.h>
+#include <stdlib.h>
 #include <algorithm>
 #include <atomic>
 #include <chrono>
@@ -25,6 +26,12 @@
 #include "opentelemetry/sdk/trace/span_data.h"
 #include "opentelemetry/version.h"
 
+#if defined(_MSC_VER)
+#  include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#endif
+
 OPENTELEMETRY_BEGIN_NAMESPACE
 
 /**
@@ -364,4 +371,78 @@ TEST_F(BatchSpanProcessorTestPeer, TestScheduleDelayMillis)
   }
 }
 
+TEST(BatchSpanProcessorOptionsEnvTest, TestDefaultValues)
+{
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.max_queue_size, static_cast<size_t>(2084));
+  EXPECT_EQ(options.schedule_delay_millis, std::chrono::milliseconds(5000));
+  EXPECT_EQ(options.export_timeout, std::chrono::milliseconds(3000));
+  EXPECT_EQ(options.max_export_batch_size, static_cast<size_t>(512));
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestMaxQueueSizeFromEnv)
+{
+  setenv("OTEL_BSP_MAX_QUEUE_SIZE", "1234", 1);
+
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.max_queue_size, static_cast<size_t>(1234));
+
+  unsetenv("OTEL_BSP_MAX_QUEUE_SIZE");
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestScheduleDelayFromEnv)
+{
+  setenv("OTEL_BSP_SCHEDULE_DELAY", "7s", 1);
+
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.schedule_delay_millis, std::chrono::milliseconds(7000));
+
+  unsetenv("OTEL_BSP_SCHEDULE_DELAY");
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestExportTimeoutFromEnv)
+{
+  setenv("OTEL_BSP_EXPORT_TIMEOUT", "250ms", 1);
+
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.export_timeout, std::chrono::milliseconds(250));
+
+  unsetenv("OTEL_BSP_EXPORT_TIMEOUT");
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestMaxExportBatchSizeFromEnv)
+{
+  setenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", "42", 1);
+
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.max_export_batch_size, static_cast<size_t>(42));
+
+  unsetenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE");
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestOptionsReadFromMultipleEnvVars)
+{
+  setenv("OTEL_BSP_MAX_QUEUE_SIZE", "3000", 1);
+  setenv("OTEL_BSP_SCHEDULE_DELAY", "2s", 1);
+  setenv("OTEL_BSP_EXPORT_TIMEOUT", "1s", 1);
+  setenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", "256", 1);
+
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.max_queue_size, static_cast<size_t>(3000));
+  EXPECT_EQ(options.schedule_delay_millis, std::chrono::milliseconds(2000));
+  EXPECT_EQ(options.export_timeout, std::chrono::milliseconds(1000));
+  EXPECT_EQ(options.max_export_batch_size, static_cast<size_t>(256));
+
+  unsetenv("OTEL_BSP_MAX_QUEUE_SIZE");
+  unsetenv("OTEL_BSP_SCHEDULE_DELAY");
+  unsetenv("OTEL_BSP_EXPORT_TIMEOUT");
+  unsetenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE");
+}
+
 OPENTELEMETRY_END_NAMESPACE