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..32c0127a0f 100644 --- a/sdk/include/opentelemetry/sdk/trace/batch_span_processor_options.h +++ b/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 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..c9e51e16ac --- /dev/null +++ b/sdk/src/trace/batch_span_processor_options.cc @@ -0,0 +1,69 @@ +// 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" +#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(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(kMaxExportBatchSizeEnv, value)) + { + return kDefaultMaxExportBatchSize; + } + return static_cast(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 diff --git a/sdk/test/trace/batch_span_processor_test.cc b/sdk/test/trace/batch_span_processor_test.cc index af9bbeab5e..1e8d5734ef 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,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(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("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("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(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(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("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