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

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

@@ -5,6 +5,7 @@
 
 #include <chrono>
 
+#include "opentelemetry/sdk/common/env_variables.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -14,6 +15,73 @@ namespace sdk
 namespace trace
 {
 
+constexpr const char *kMaxQueueSize       = "OTEL_BSP_MAX_QUEUE_SIZE";
+constexpr const char *kScheduleDelay      = "OTEL_BSP_SCHEDULE_DELAY";
+constexpr const char *kExportTimeout      = "OTEL_BSP_EXPORT_TIMEOUT";
+constexpr const char *kMaxExportBatchSize = "OTEL_BSP_MAX_EXPORT_BATCH_SIZE";
+
+// The default max queue size is 2084
+const size_t kDefaultMaxQueueSize = 2084;
+// It is the default delay between two consecutive exports and default is 5000 milliseconds
+const std::chrono::milliseconds kDefaultScheduleDelayMillis = std::chrono::milliseconds(5000);
+// It is the default duration after which an export is cancelled and default is 3000 milliseconds.
+const std::chrono::milliseconds kDefaultExportTimeout = std::chrono::milliseconds(3000);
+// It is the default max batch size of every export and it is 512
+const size_t kDefaultMaxExportBatchSize = 512;
+
+/**
+ * Reads the maximum queue size from the environment variable OTEL_BSP_MAX_QUEUE_SIZE.
+ * If the environment variable is not set, returns the default value kDefaultMaxQueueSize.
+ * This value determines the maximum number of spans that can be buffered before dropping.
+ */
+inline size_t GetMaxQueueSizeFromEnv()
+{
+  std::uint32_t max_queue_size;
+  bool exists =
+      opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxQueueSize, max_queue_size);
+  if (exists == false)
+  {
+    return kDefaultMaxQueueSize;
+  }
+  return static_cast<size_t>(max_queue_size);
+}
+
+/**
+ * Reads a duration from the specified environment variable.
+ * If the variable is not set, returns the provided default_duration.
+ * Converts the returned duration to milliseconds regardless of the original unit.
+ * Used for schedule delays and export timeouts.
+ */
+inline std::chrono::milliseconds GetDurationFromEnv(
+    const char *env_var,
+    const std::chrono::milliseconds &default_duration)
+{
+  std::chrono::system_clock::duration duration{0};
+  bool exists = opentelemetry::sdk::common::GetDurationEnvironmentVariable(env_var, duration);
+  if (exists == false)
+  {
+    return default_duration;
+  }
+  return std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+}
+
+/**
+ * Reads the maximum export batch size from the environment variable OTEL_BSP_MAX_EXPORT_BATCH_SIZE.
+ * If the environment variable is not set, returns the default value kDefaultMaxExportBatchSize.
+ * This determines the maximum number of spans exported in a single batch.
+ */
+inline size_t GetMaxExportBatchSizeFromEnv()
+{
+  std::uint32_t max_export_batch_size;
+  bool exists = opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxExportBatchSize,
+                                                                       max_export_batch_size);
+  if (exists == false)
+  {
+    return kDefaultMaxExportBatchSize;
+  }
+  return static_cast<size_t>(max_export_batch_size);
+}
+
 /**
  * Struct to hold batch SpanProcessor options.
  */
@@ -23,16 +91,23 @@ struct 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 = GetMaxQueueSizeFromEnv();
 
   /* The time interval between two consecutive exports. */
-  std::chrono::milliseconds schedule_delay_millis = std::chrono::milliseconds(5000);
+  std::chrono::milliseconds schedule_delay_millis =
+      GetDurationFromEnv(kScheduleDelay, kDefaultScheduleDelayMillis);
+
+  /**
+   * The maximum time allowed to to export data
+   */
+  std::chrono::milliseconds export_timeout =
+      GetDurationFromEnv(kExportTimeout, kDefaultExportTimeout);
 
   /**
    * 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 = GetMaxExportBatchSizeFromEnv();
 };
 
 }  // namespace trace

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,11 @@
 #include "opentelemetry/sdk/trace/span_data.h"
 #include "opentelemetry/version.h"
 
+#if defined(_MSC_VER)
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#endif
+
 OPENTELEMETRY_BEGIN_NAMESPACE
 
 /**
@@ -364,4 +370,66 @@ TEST_F(BatchSpanProcessorTestPeer, TestScheduleDelayMillis)
   }
 }
 
+TEST(BatchSpanProcessorOptionsEnvTest, TestDefaultValues)
+{
+  sdk::trace::BatchSpanProcessorOptions options;
+
+  EXPECT_EQ(options.max_queue_size, sdk::trace::kDefaultMaxQueueSize);
+  EXPECT_EQ(options.schedule_delay_millis, sdk::trace::kDefaultScheduleDelayMillis);
+  EXPECT_EQ(options.export_timeout, sdk::trace::kDefaultExportTimeout);
+  EXPECT_EQ(options.max_export_batch_size, sdk::trace::kDefaultMaxExportBatchSize);
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestMaxQueueSizeFromEnv)
+{
+  setenv(sdk::trace::kMaxQueueSize, "1234", 1);
+  EXPECT_EQ(sdk::trace::GetMaxQueueSizeFromEnv(), static_cast<size_t>(1234));
+  unsetenv(sdk::trace::kMaxQueueSize);
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestScheduleDelayFromEnv)
+{
+  setenv(sdk::trace::kScheduleDelay, "7s", 1);
+  EXPECT_EQ(sdk::trace::GetDurationFromEnv(sdk::trace::kScheduleDelay,
+                                           sdk::trace::kDefaultScheduleDelayMillis),
+            std::chrono::milliseconds(7000));
+  unsetenv(sdk::trace::kScheduleDelay);
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestExportTimeoutFromEnv)
+{
+  setenv(sdk::trace::kExportTimeout, "250ms", 1);
+  EXPECT_EQ(
+      sdk::trace::GetDurationFromEnv(sdk::trace::kExportTimeout, sdk::trace::kDefaultExportTimeout),
+      std::chrono::milliseconds(250));
+  unsetenv(sdk::trace::kExportTimeout);
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestMaxExportBatchSizeFromEnv)
+{
+  setenv(sdk::trace::kMaxExportBatchSize, "42", 1);
+  EXPECT_EQ(sdk::trace::GetMaxExportBatchSizeFromEnv(), static_cast<size_t>(42));
+  unsetenv(sdk::trace::kMaxExportBatchSize);
+}
+
+TEST(BatchSpanProcessorOptionsEnvTest, TestOptionsReadFromEnv)
+{
+  setenv(sdk::trace::kMaxQueueSize, "3000", 1);
+  setenv(sdk::trace::kScheduleDelay, "2s", 1);
+  setenv(sdk::trace::kExportTimeout, "1s", 1);
+  setenv(sdk::trace::kMaxExportBatchSize, "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(sdk::trace::kMaxQueueSize);
+  unsetenv(sdk::trace::kScheduleDelay);
+  unsetenv(sdk::trace::kExportTimeout);
+  unsetenv(sdk::trace::kMaxExportBatchSize);
+}
+
 OPENTELEMETRY_END_NAMESPACE