From 48d9536d3fa6ded1b06f3fab5ac5989167a7bee8 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Fri, 26 Sep 2025 01:53:01 +0530 Subject: [PATCH 1/9] [TRACE SDK] Batch span processor options now using env variables --- .../sdk/trace/batch_span_processor_options.h | 81 ++++++++++++++++++- sdk/test/trace/batch_span_processor_test.cc | 62 ++++++++++++++ 2 files changed, 140 insertions(+), 3 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h index ac1052383b..f26d11054b 100644 --- a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h +++ b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h @@ -5,6 +5,7 @@ #include +#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(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(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(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 diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index af9bbeab5e..ee3aa89869 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -364,4 +364,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(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(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(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(256)); + + unsetenv(sdk::trace::kMaxQueueSize); + unsetenv(sdk::trace::kScheduleDelay); + unsetenv(sdk::trace::kExportTimeout); + unsetenv(sdk::trace::kMaxExportBatchSize); +} + OPENTELEMETRY_END_NAMESPACE From 185555323729aeaa84b2b056ea0ef6f461795a7e Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Fri, 26 Sep 2025 09:20:30 +0530 Subject: [PATCH 2/9] windows fix --- sdk/test/trace/batch_span_processor_test.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index ee3aa89869..549924437d 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -2,6 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 #include +#include #include #include #include @@ -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 /** From 6774cffcd7fc28b3c24bd481d2901bfd34d3afd3 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Fri, 26 Sep 2025 15:24:47 +0530 Subject: [PATCH 3/9] options.cc file --- .../sdk/trace/batch_span_processor_options.h | 78 ++----------------- sdk/src/trace/CMakeLists.txt | 1 + sdk/src/trace/batch_span_processor_options.cc | 66 ++++++++++++++++ sdk/test/trace/batch_span_processor_test.cc | 70 ++++++++++------- 4 files changed, 113 insertions(+), 102 deletions(-) create mode 100644 sdk/src/trace/batch_span_processor_options.cc diff --git a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h index f26d11054b..9528281943 100644 --- a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h +++ b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h @@ -15,99 +15,31 @@ 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(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(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(max_export_batch_size); -} - /** * Struct to hold batch SpanProcessor options. */ struct BatchSpanProcessorOptions { + BatchSpanProcessorOptions(); /** * The maximum buffer/queue size. After the size is reached, spans are * dropped. */ - size_t max_queue_size = GetMaxQueueSizeFromEnv(); + size_t max_queue_size = 2048; /* The time interval between two consecutive exports. */ - std::chrono::milliseconds schedule_delay_millis = - GetDurationFromEnv(kScheduleDelay, kDefaultScheduleDelayMillis); + std::chrono::milliseconds schedule_delay_millis = std::chrono::milliseconds(5000); /** * The maximum time allowed to to export data */ - std::chrono::milliseconds export_timeout = - GetDurationFromEnv(kExportTimeout, kDefaultExportTimeout); + std::chrono::milliseconds export_timeout = std::chrono::milliseconds(3000); /** * The maximum batch size of every export. It must be smaller or * equal to max_queue_size. */ - size_t max_export_batch_size = GetMaxExportBatchSizeFromEnv(); + size_t max_export_batch_size = 512; }; } // namespace trace diff --git a/sdk/src/trace/CMakeLists.txt b/sdk/src/trace/CMakeLists.txt index 5d7a36dbf5..95eb541e20 100644 --- a/sdk/src/trace/CMakeLists.txt +++ b/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 diff --git a/sdk/src/trace/batch_span_processor_options.cc b/sdk/src/trace/batch_span_processor_options.cc new file mode 100644 index 0000000000..08dab9162b --- /dev/null +++ b/sdk/src/trace/batch_span_processor_options.cc @@ -0,0 +1,66 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include + +#include "opentelemetry/sdk/common/env_variables.h" +#include "opentelemetry/sdk/trace/batch_span_processor_options.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +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"; + +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(kMaxQueueSize, value)) + { + return kDefaultMaxQueueSize; + } + return static_cast(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(duration); +} + +inline size_t GetMaxExportBatchSizeFromEnv() +{ + std::uint32_t value; + if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxExportBatchSize, value)) + { + return kDefaultMaxExportBatchSize; + } + return static_cast(value); +} + +BatchSpanProcessorOptions::BatchSpanProcessorOptions() + : max_queue_size(GetMaxQueueSizeFromEnv()), + schedule_delay_millis(GetDurationFromEnv(kScheduleDelay, kDefaultScheduleDelayMillis)), + export_timeout(GetDurationFromEnv(kExportTimeout, kDefaultExportTimeout)), + max_export_batch_size(GetMaxExportBatchSizeFromEnv()) +{} + +} // namespace trace +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index 549924437d..d387bb19dc 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -374,50 +374,62 @@ 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); + EXPECT_EQ(options.max_queue_size, static_cast(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(512)); } TEST(BatchSpanProcessorOptionsEnvTest, TestMaxQueueSizeFromEnv) { - setenv(sdk::trace::kMaxQueueSize, "1234", 1); - EXPECT_EQ(sdk::trace::GetMaxQueueSizeFromEnv(), static_cast(1234)); - unsetenv(sdk::trace::kMaxQueueSize); + setenv("OTEL_BSP_MAX_QUEUE_SIZE", "1234", 1); + + sdk::trace::BatchSpanProcessorOptions options; + + EXPECT_EQ(options.max_queue_size, static_cast(1234)); + + unsetenv("OTEL_BSP_MAX_QUEUE_SIZE"); } 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); + 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(sdk::trace::kExportTimeout, "250ms", 1); - EXPECT_EQ( - sdk::trace::GetDurationFromEnv(sdk::trace::kExportTimeout, sdk::trace::kDefaultExportTimeout), - std::chrono::milliseconds(250)); - unsetenv(sdk::trace::kExportTimeout); + 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(sdk::trace::kMaxExportBatchSize, "42", 1); - EXPECT_EQ(sdk::trace::GetMaxExportBatchSizeFromEnv(), static_cast(42)); - unsetenv(sdk::trace::kMaxExportBatchSize); + setenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", "42", 1); + + sdk::trace::BatchSpanProcessorOptions options; + + EXPECT_EQ(options.max_export_batch_size, static_cast(42)); + + unsetenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"); } -TEST(BatchSpanProcessorOptionsEnvTest, TestOptionsReadFromEnv) +TEST(BatchSpanProcessorOptionsEnvTest, TestOptionsReadFromMultipleEnvVars) { - setenv(sdk::trace::kMaxQueueSize, "3000", 1); - setenv(sdk::trace::kScheduleDelay, "2s", 1); - setenv(sdk::trace::kExportTimeout, "1s", 1); - setenv(sdk::trace::kMaxExportBatchSize, "256", 1); + 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; @@ -426,10 +438,10 @@ TEST(BatchSpanProcessorOptionsEnvTest, TestOptionsReadFromEnv) EXPECT_EQ(options.export_timeout, std::chrono::milliseconds(1000)); EXPECT_EQ(options.max_export_batch_size, static_cast(256)); - unsetenv(sdk::trace::kMaxQueueSize); - unsetenv(sdk::trace::kScheduleDelay); - unsetenv(sdk::trace::kExportTimeout); - unsetenv(sdk::trace::kMaxExportBatchSize); + 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 From 14f18436851393504d178cadb106fad4bbb418ca Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Fri, 26 Sep 2025 20:51:50 +0530 Subject: [PATCH 4/9] iwyu fix --- sdk/src/trace/batch_span_processor_options.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sdk/src/trace/batch_span_processor_options.cc b/sdk/src/trace/batch_span_processor_options.cc index 08dab9162b..5da4a24da8 100644 --- a/sdk/src/trace/batch_span_processor_options.cc +++ b/sdk/src/trace/batch_span_processor_options.cc @@ -1,7 +1,9 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +#include #include +#include #include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/sdk/trace/batch_span_processor_options.h" From 0030ae0c271db1aa2644a8a2dcbcb091e36a026e Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Fri, 26 Sep 2025 21:42:49 +0530 Subject: [PATCH 5/9] iwyu fix --- sdk/src/trace/batch_span_processor_options.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/sdk/src/trace/batch_span_processor_options.cc b/sdk/src/trace/batch_span_processor_options.cc index 5da4a24da8..08199bc45b 100644 --- a/sdk/src/trace/batch_span_processor_options.cc +++ b/sdk/src/trace/batch_span_processor_options.cc @@ -7,6 +7,7 @@ #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 From 7ceb2e315e869602aae38218c196da6dc0db04f8 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Wed, 1 Oct 2025 01:03:19 +0530 Subject: [PATCH 6/9] minor changes --- .../sdk/trace/batch_span_processor_options.h | 13 +++++++------ sdk/src/trace/batch_span_processor_options.cc | 16 ++++++++-------- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h index 9528281943..32c0127a0f 100644 --- a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h +++ b/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h @@ -5,7 +5,6 @@ #include -#include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE @@ -18,28 +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 = std::chrono::milliseconds(3000); + 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 diff --git a/sdk/src/trace/batch_span_processor_options.cc b/sdk/src/trace/batch_span_processor_options.cc index 08199bc45b..c9e51e16ac 100644 --- a/sdk/src/trace/batch_span_processor_options.cc +++ b/sdk/src/trace/batch_span_processor_options.cc @@ -15,10 +15,10 @@ 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"; +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); @@ -28,7 +28,7 @@ const size_t kDefaultMaxExportBatchSize = 512; inline size_t GetMaxQueueSizeFromEnv() { std::uint32_t value; - if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxQueueSize, value)) + if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxQueueSizeEnv, value)) { return kDefaultMaxQueueSize; } @@ -50,7 +50,7 @@ inline std::chrono::milliseconds GetDurationFromEnv( inline size_t GetMaxExportBatchSizeFromEnv() { std::uint32_t value; - if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxExportBatchSize, value)) + if (!opentelemetry::sdk::common::GetUintEnvironmentVariable(kMaxExportBatchSizeEnv, value)) { return kDefaultMaxExportBatchSize; } @@ -59,8 +59,8 @@ inline size_t GetMaxExportBatchSizeFromEnv() BatchSpanProcessorOptions::BatchSpanProcessorOptions() : max_queue_size(GetMaxQueueSizeFromEnv()), - schedule_delay_millis(GetDurationFromEnv(kScheduleDelay, kDefaultScheduleDelayMillis)), - export_timeout(GetDurationFromEnv(kExportTimeout, kDefaultExportTimeout)), + schedule_delay_millis(GetDurationFromEnv(kScheduleDelayEnv, kDefaultScheduleDelayMillis)), + export_timeout(GetDurationFromEnv(kExportTimeoutEnv, kDefaultExportTimeout)), max_export_batch_size(GetMaxExportBatchSizeFromEnv()) {} From b422a5f38e1246ee7d4f10e71695729d2e9e87ec Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Wed, 1 Oct 2025 12:32:21 +0530 Subject: [PATCH 7/9] env fix --- sdk/test/trace/batch_span_processor_test.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index d387bb19dc..5e1a9059d7 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -16,6 +16,7 @@ #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/sdk/common/attribute_utils.h" +#include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/sdk/common/exporter_utils.h" #include "opentelemetry/sdk/common/global_log_handler.h" #include "opentelemetry/sdk/trace/batch_span_processor.h" From cadb1602bf2a1630540ca08398c131a390eec6fd Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Wed, 1 Oct 2025 12:56:09 +0530 Subject: [PATCH 8/9] iwyu fix --- sdk/test/trace/batch_span_processor_test.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index 5e1a9059d7..7eaa812af7 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -28,6 +28,7 @@ #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 From e9010ebce6fc986fc3f698f32ff4b90546694348 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Wed, 1 Oct 2025 12:56:49 +0530 Subject: [PATCH 9/9] more iwyu fix --- sdk/test/trace/batch_span_processor_test.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index 7eaa812af7..1e8d5734ef 100644 --- a/sdk/test/trace/batch_span_processor_test.cc +++ b/sdk/test/trace/batch_span_processor_test.cc @@ -16,7 +16,6 @@ #include "opentelemetry/nostd/span.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/sdk/common/attribute_utils.h" -#include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/sdk/common/exporter_utils.h" #include "opentelemetry/sdk/common/global_log_handler.h" #include "opentelemetry/sdk/trace/batch_span_processor.h"