From e383cc8747603a0fde4d9221e00cc34412327c6c Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Wed, 15 Jul 2026 15:15:42 +0530 Subject: [PATCH 01/12] Update OtlpGrpcClientOptions to populate options for gRPC client sharing Fixes #4239 OtlpGrpcClientOptions previously only had a = default constructor, leaving every option at null/zero. Add a real default constructor that populates spec-compliant defaults from generic (signal-independent) OTEL_EXPORTER_OTLP_* environment variables, a void* constructor that skips defaults, and a constructor on each of OtlpGrpcExporterOptions, OtlpGrpcMetricExporterOptions, and OtlpGrpcLogRecordExporterOptions that builds from a shared OtlpGrpcClientOptions, copying client-fixed fields and overriding only timeout, metadata, and max_concurrent_requests per signal. Signed-off-by: Ansh Rai --- CHANGELOG.md | 11 + exporters/otlp/BUILD | 19 ++ exporters/otlp/CMakeLists.txt | 15 +- .../exporters/otlp/otlp_environment.h | 226 ++++++++++++++++++ .../exporters/otlp/otlp_grpc_client_options.h | 10 +- .../otlp/otlp_grpc_exporter_options.h | 1 + .../otlp_grpc_log_record_exporter_options.h | 1 + .../otlp/otlp_grpc_metric_exporter_options.h | 1 + .../otlp/src/otlp_grpc_client_options.cc | 59 +++++ .../otlp/src/otlp_grpc_exporter_options.cc | 13 +- .../otlp_grpc_log_record_exporter_options.cc | 13 + .../src/otlp_grpc_metric_exporter_options.cc | 16 +- .../test/otlp_grpc_client_options_test.cc | 138 +++++++++++ 13 files changed, 518 insertions(+), 5 deletions(-) create mode 100644 exporters/otlp/src/otlp_grpc_client_options.cc create mode 100644 exporters/otlp/test/otlp_grpc_client_options_test.cc diff --git a/CHANGELOG.md b/CHANGELOG.md index 19e3c1d41a..4a794927e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,17 @@ Increment the: * docs: update supported development platforms [#4260](https://github.com/open-telemetry/opentelemetry-cpp/pull/4260) +* [EXPORTER] Populate `OtlpGrpcClientOptions` with spec-compliant environment + variable defaults, and add constructors to `OtlpGrpcExporterOptions` / + `OtlpGrpcMetricExporterOptions` / `OtlpGrpcLogRecordExporterOptions` that + build from a shared `OtlpGrpcClientOptions`, to support sharing one gRPC + client across the trace, metric, and log exporters. + [#4239](https://github.com/open-telemetry/opentelemetry-cpp/issues/4239) + +* [SDK] Apply metric cardinality limits to non-overflow attribute sets and + reserve the overflow point separately. + [#4236](https://github.com/open-telemetry/opentelemetry-cpp/pull/4236) + * [RELEASE] Bump main branch to 1.29.0-dev [#4259](https://github.com/open-telemetry/opentelemetry-cpp/pull/4259) diff --git a/exporters/otlp/BUILD b/exporters/otlp/BUILD index f756afa698..2ff1fadac0 100644 --- a/exporters/otlp/BUILD +++ b/exporters/otlp/BUILD @@ -77,6 +77,7 @@ cc_library( srcs = [ "src/otlp_grpc_client.cc", "src/otlp_grpc_client_factory.cc", + "src/otlp_grpc_client_options.cc", "src/otlp_grpc_utils.cc", ], hdrs = [ @@ -99,6 +100,7 @@ cc_library( ], deps = [ "//ext:headers", + "//sdk/src/common:env_variables", "//sdk/src/common:global_log_handler", "@com_github_grpc_grpc//:grpc++", "@com_github_opentelemetry_proto//:common_proto_cc", @@ -733,6 +735,23 @@ cc_test( ], ) +cc_test( + name = "otlp_grpc_client_options_test", + srcs = ["test/otlp_grpc_client_options_test.cc"], + tags = [ + "otlp", + "otlp_grpc", + "test", + ], + deps = [ + ":otlp_grpc_client", + ":otlp_grpc_exporter", + ":otlp_grpc_metric_exporter", + ":otlp_grpc_log_record_exporter", + "@com_google_googletest//:gtest_main", + ], +) + cc_test( name = "otlp_grpc_exporter_factory_test", srcs = ["test/otlp_grpc_exporter_factory_test.cc"], diff --git a/exporters/otlp/CMakeLists.txt b/exporters/otlp/CMakeLists.txt index 792e25ccf2..3b0cd23989 100644 --- a/exporters/otlp/CMakeLists.txt +++ b/exporters/otlp/CMakeLists.txt @@ -97,7 +97,8 @@ if(WITH_OTLP_GRPC) add_library( opentelemetry_exporter_otlp_grpc_client ${OPENTELEMETRY_OTLP_GRPC_CLIENT_LIB_TYPE} src/otlp_grpc_client.cc - src/otlp_grpc_client_factory.cc src/otlp_grpc_utils.cc) + src/otlp_grpc_client_factory.cc src/otlp_grpc_client_options.cc + src/otlp_grpc_utils.cc) set_target_properties(opentelemetry_exporter_otlp_grpc_client PROPERTIES EXPORT_NAME otlp_grpc_client) set_target_version(opentelemetry_exporter_otlp_grpc_client) @@ -936,6 +937,18 @@ if(BUILD_TESTING) TEST_PREFIX exporter.otlp. TEST_LIST otlp_grpc_target_test) + add_executable(otlp_grpc_client_options_test + test/otlp_grpc_client_options_test.cc) + target_link_libraries( + otlp_grpc_client_options_test ${GTEST_BOTH_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} ${GMOCK_LIB} opentelemetry_exporter_otlp_grpc + opentelemetry_exporter_otlp_grpc_log + opentelemetry_exporter_otlp_grpc_metrics) + gtest_add_tests( + TARGET otlp_grpc_client_options_test + TEST_PREFIX exporter.otlp. + TEST_LIST otlp_grpc_client_options_test) + add_executable(otlp_grpc_exporter_factory_test test/otlp_grpc_exporter_factory_test.cc) target_link_libraries( diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h index f6ea55d32d..67db6ec317 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h @@ -6,9 +6,15 @@ #include #include #include +#include #include #include +#include +#include +#include "opentelemetry/common/kv_properties.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/sdk/version/version.h" #include "opentelemetry/version.h" @@ -168,6 +174,226 @@ float GetOtlpDefaultTracesRetryBackoffMultiplier(); float GetOtlpDefaultMetricsRetryBackoffMultiplier(); float GetOtlpDefaultLogsRetryBackoffMultiplier(); +/** + * Signal-independent accessors, for use by a gRPC client shared across + * multiple signal exporters. These read only the generic OTEL_EXPORTER_OTLP_* + * environment variables and fall back to the same spec defaults used above. + */ + +inline std::string GetOtlpDefaultGrpcClientEndpoint() +{ + constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4317"; + + std::string value; + + if (opentelemetry::sdk::common::GetStringEnvironmentVariable(kGenericEnv, value)) + { + return value; + } + + return kDefault; +} + +inline bool GetOtlpDefaultGrpcClientIsInsecure() +{ + std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); + + if (endpoint.substr(0, 6) == "https:") + { + return false; + } + + if (endpoint.substr(0, 5) == "http:") + { + return true; + } + + constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_INSECURE"; + constexpr char kOldGenericEnv[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; + + bool insecure{}; + bool ssl_enabled{}; + + if (opentelemetry::sdk::common::GetBoolEnvironmentVariable(kGenericEnv, insecure)) + { + return insecure; + } + + if (opentelemetry::sdk::common::GetBoolEnvironmentVariable(kOldGenericEnv, ssl_enabled)) + { + return !ssl_enabled; + } + + return false; +} + +inline std::string GetOtlpDefaultGrpcClientSslCertificatePath() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CERTIFICATE", value); + return value; +} + +inline std::string GetOtlpDefaultGrpcClientSslCertificateString() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CERTIFICATE_STRING", + value); + return value; +} + +inline std::string GetOtlpDefaultGrpcClientSslClientKeyPath() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_KEY", value); + return value; +} + +inline std::string GetOtlpDefaultGrpcClientSslClientKeyString() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING", + value); + return value; +} + +inline std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", + value); + return value; +} + +inline std::string GetOtlpDefaultGrpcClientSslClientCertificateString() +{ + std::string value; + opentelemetry::sdk::common::GetStringEnvironmentVariable( + "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING", value); + return value; +} + +inline std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() +{ + constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; + + std::chrono::system_clock::duration value; + + if (opentelemetry::sdk::common::GetDurationEnvironmentVariable(kGenericEnv, value)) + { + return value; + } + + return std::chrono::duration_cast(std::chrono::seconds{10}); +} + +inline OtlpHeaders GetOtlpDefaultGrpcClientHeaders() +{ + OtlpHeaders result; + + std::string raw_value; + if (!opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_HEADERS", + raw_value)) + { + return result; + } + + opentelemetry::common::KeyValueStringTokenizer tokenizer{raw_value}; + opentelemetry::nostd::string_view header_key; + opentelemetry::nostd::string_view header_value; + bool header_valid = true; + + std::unordered_set remove_cache; + + while (tokenizer.next(header_valid, header_key, header_value)) + { + if (header_valid) + { + std::string key(header_key); + if (remove_cache.end() == remove_cache.find(key)) + { + remove_cache.insert(key); + auto range = result.equal_range(key); + if (range.first != range.second) + { + result.erase(range.first, range.second); + } + } + + std::string value(header_value); + result.emplace(std::make_pair(std::move(key), std::move(value))); + } + } + + return result; +} + +inline std::string GetOtlpDefaultGrpcClientCompression() +{ + std::string value; + + if (opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_COMPRESSION", + value)) + { + return value; + } + + return std::string{"none"}; +} + +inline std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() +{ + std::uint32_t value{}; + + if (opentelemetry::sdk::common::GetUintEnvironmentVariable( + "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS", value)) + { + return value; + } + + return 5U; +} + +inline std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() +{ + float value{}; + + if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( + "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF", value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{1.0f}; +} + +inline std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() +{ + float value{}; + + if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( + "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF", value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{5.0f}; +} + +inline float GetOtlpDefaultGrpcClientRetryBackoffMultiplier() +{ + float value{}; + + if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( + "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER", value)) + { + return value; + } + + return 1.5f; +} + } // namespace otlp } // namespace exporter OPENTELEMETRY_END_NAMESPACE diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h index f524b27b9a..25388f044f 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h @@ -24,8 +24,14 @@ namespace otlp struct OtlpGrpcClientOptions { - virtual ~OtlpGrpcClientOptions() = default; - OtlpGrpcClientOptions() = default; + virtual ~OtlpGrpcClientOptions(); + + /** Lookup environment variables, and populate spec-compliant defaults. */ + OtlpGrpcClientOptions(); + + /** No defaults. */ + explicit OtlpGrpcClientOptions(void *); + OtlpGrpcClientOptions(const OtlpGrpcClientOptions &) = default; OtlpGrpcClientOptions(OtlpGrpcClientOptions &&) = default; OtlpGrpcClientOptions &operator=(const OtlpGrpcClientOptions &) = default; diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h index 94d028978f..2f569cf9ef 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h @@ -29,6 +29,7 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcExporterOptions : public OtlpGrpcClientOptio OtlpGrpcExporterOptions(); /** No defaults. */ OtlpGrpcExporterOptions(void *); + explicit OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &client_options); OtlpGrpcExporterOptions(const OtlpGrpcExporterOptions &) = default; OtlpGrpcExporterOptions(OtlpGrpcExporterOptions &&) = default; OtlpGrpcExporterOptions &operator=(const OtlpGrpcExporterOptions &) = default; diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h index 8e6f53644d..67b2917c0d 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h @@ -27,6 +27,7 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcLogRecordExporterOptions : public OtlpGrpcCl OtlpGrpcLogRecordExporterOptions(); /** No defaults. */ OtlpGrpcLogRecordExporterOptions(void *); + explicit OtlpGrpcLogRecordExporterOptions(const OtlpGrpcClientOptions &client_options); OtlpGrpcLogRecordExporterOptions(const OtlpGrpcLogRecordExporterOptions &) = default; OtlpGrpcLogRecordExporterOptions(OtlpGrpcLogRecordExporterOptions &&) = default; OtlpGrpcLogRecordExporterOptions &operator=(const OtlpGrpcLogRecordExporterOptions &) = default; diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h index ab6c8795f7..628ece589d 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h @@ -28,6 +28,7 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcMetricExporterOptions : public OtlpGrpcClien OtlpGrpcMetricExporterOptions(); /** No defaults. */ OtlpGrpcMetricExporterOptions(void *); + explicit OtlpGrpcMetricExporterOptions(const OtlpGrpcClientOptions &client_options); OtlpGrpcMetricExporterOptions(const OtlpGrpcMetricExporterOptions &) = default; OtlpGrpcMetricExporterOptions(OtlpGrpcMetricExporterOptions &&) = default; OtlpGrpcMetricExporterOptions &operator=(const OtlpGrpcMetricExporterOptions &) = default; diff --git a/exporters/otlp/src/otlp_grpc_client_options.cc b/exporters/otlp/src/otlp_grpc_client_options.cc new file mode 100644 index 0000000000..66782737b0 --- /dev/null +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -0,0 +1,59 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" +#include "opentelemetry/exporters/otlp/otlp_environment.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace exporter +{ +namespace otlp +{ + +OtlpGrpcClientOptions::OtlpGrpcClientOptions() +{ + endpoint = GetOtlpDefaultGrpcClientEndpoint(); + use_ssl_credentials = !GetOtlpDefaultGrpcClientIsInsecure(); + ssl_credentials_cacert_path = GetOtlpDefaultGrpcClientSslCertificatePath(); + ssl_credentials_cacert_as_string = GetOtlpDefaultGrpcClientSslCertificateString(); + +#ifdef ENABLE_OTLP_GRPC_SSL_MTLS_PREVIEW + ssl_client_key_path = GetOtlpDefaultGrpcClientSslClientKeyPath(); + ssl_client_key_string = GetOtlpDefaultGrpcClientSslClientKeyString(); + ssl_client_cert_path = GetOtlpDefaultGrpcClientSslClientCertificatePath(); + ssl_client_cert_string = GetOtlpDefaultGrpcClientSslClientCertificateString(); +#endif + + timeout = GetOtlpDefaultGrpcClientTimeout(); + metadata = GetOtlpDefaultGrpcClientHeaders(); + user_agent = GetOtlpDefaultUserAgent(); + + max_threads = 0; + + compression = GetOtlpDefaultGrpcClientCompression(); +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests = 64; +#endif + + retry_policy_max_attempts = GetOtlpDefaultGrpcClientRetryMaxAttempts(); + retry_policy_initial_backoff = GetOtlpDefaultGrpcClientRetryInitialBackoff(); + retry_policy_max_backoff = GetOtlpDefaultGrpcClientRetryMaxBackoff(); + retry_policy_backoff_multiplier = GetOtlpDefaultGrpcClientRetryBackoffMultiplier(); +} + +OtlpGrpcClientOptions::OtlpGrpcClientOptions(void *) +{ + use_ssl_credentials = true; + max_threads = 0; + +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests = 64; +#endif +} + +OtlpGrpcClientOptions::~OtlpGrpcClientOptions() {} + +} // namespace otlp +} // namespace exporter +OPENTELEMETRY_END_NAMESPACE \ No newline at end of file diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 482a5193ec..82b229c9db 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -45,7 +45,7 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() retry_policy_backoff_multiplier = GetOtlpDefaultTracesRetryBackoffMultiplier(); } -OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) : OtlpGrpcClientOptions(nullptr) { use_ssl_credentials = true; max_threads = 0; @@ -55,6 +55,17 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) #endif } +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options) +{ + timeout = GetOtlpDefaultTracesTimeout(); + metadata = GetOtlpDefaultTracesHeaders(); + +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests = 64; +#endif +} + OtlpGrpcExporterOptions::~OtlpGrpcExporterOptions() {} } // namespace otlp diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index 55c108c03d..4b2669ea08 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -46,6 +46,7 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions() } OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions(void *) + : OtlpGrpcClientOptions(nullptr) { use_ssl_credentials = true; max_threads = 0; @@ -55,6 +56,18 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions(void *) #endif } +OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( + const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options) +{ + timeout = GetOtlpDefaultLogsTimeout(); + metadata = GetOtlpDefaultLogsHeaders(); + +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests = 64; +#endif +} + OtlpGrpcLogRecordExporterOptions::~OtlpGrpcLogRecordExporterOptions() {} } // namespace otlp diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index 540357ff9c..b9b40eaaca 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -48,7 +48,8 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions() } OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions(void *) - : aggregation_temporality(PreferredAggregationTemporality::kCumulative) + : OtlpGrpcClientOptions(nullptr), + aggregation_temporality(PreferredAggregationTemporality::kCumulative) { use_ssl_credentials = true; max_threads = 0; @@ -58,6 +59,19 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions(void *) #endif } +OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( + const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options), + aggregation_temporality(PreferredAggregationTemporality::kCumulative) +{ + timeout = GetOtlpDefaultMetricsTimeout(); + metadata = GetOtlpDefaultMetricsHeaders(); + +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests = 64; +#endif +} + OtlpGrpcMetricExporterOptions::~OtlpGrpcMetricExporterOptions() {} } // namespace otlp diff --git a/exporters/otlp/test/otlp_grpc_client_options_test.cc b/exporters/otlp/test/otlp_grpc_client_options_test.cc new file mode 100644 index 0000000000..717613a002 --- /dev/null +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -0,0 +1,138 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace exporter +{ +namespace otlp +{ + +namespace +{ +class ScopedEnvVar +{ +public: + ScopedEnvVar(const char *name, const char *value) : name_(name) + { +#ifdef _MSC_VER + _putenv_s(name_.c_str(), value); +#else + setenv(name_.c_str(), value, 1); +#endif + } + + ~ScopedEnvVar() + { +#ifdef _MSC_VER + _putenv_s(name_.c_str(), ""); +#else + unsetenv(name_.c_str()); +#endif + } + +private: + std::string name_; +}; +} // namespace + +TEST(OtlpGrpcClientOptionsTest, DefaultConstructorPopulatesSpecDefaults) +{ + OtlpGrpcClientOptions options; + + EXPECT_EQ(options.endpoint, "http://localhost:4317"); + EXPECT_FALSE(options.use_ssl_credentials); + EXPECT_EQ(options.compression, "none"); + EXPECT_EQ(options.retry_policy_max_attempts, 5U); + EXPECT_EQ(options.retry_policy_backoff_multiplier, 1.5f); +} + +TEST(OtlpGrpcClientOptionsTest, VoidPointerConstructorSkipsDefaults) +{ + OtlpGrpcClientOptions options(static_cast(nullptr)); + + EXPECT_TRUE(options.endpoint.empty()); + EXPECT_TRUE(options.use_ssl_credentials); +} + +TEST(OtlpGrpcClientOptionsTest, EndpointHonorsGenericEnvVar) +{ + ScopedEnvVar env("OTEL_EXPORTER_OTLP_ENDPOINT", "https://collector.example.com:4317"); + + OtlpGrpcClientOptions options; + EXPECT_EQ(options.endpoint, "https://collector.example.com:4317"); + EXPECT_TRUE(options.use_ssl_credentials); +} + +TEST(OtlpGrpcClientOptionsTest, DerivedSignalOptionsCopyFixedFieldsFromSharedClient) +{ + OtlpGrpcClientOptions client_options; + client_options.endpoint = "https://shared-collector.example.com:4317"; + client_options.compression = "gzip"; + client_options.max_threads = 7; + client_options.retry_policy_max_attempts = 3; + + OtlpGrpcExporterOptions trace_options(client_options); + EXPECT_EQ(trace_options.endpoint, client_options.endpoint); + EXPECT_EQ(trace_options.compression, client_options.compression); + EXPECT_EQ(trace_options.max_threads, client_options.max_threads); + EXPECT_EQ(trace_options.retry_policy_max_attempts, client_options.retry_policy_max_attempts); + + OtlpGrpcMetricExporterOptions metric_options(client_options); + EXPECT_EQ(metric_options.endpoint, client_options.endpoint); + EXPECT_EQ(metric_options.compression, client_options.compression); + + OtlpGrpcLogRecordExporterOptions log_options(client_options); + EXPECT_EQ(log_options.endpoint, client_options.endpoint); + EXPECT_EQ(log_options.compression, client_options.compression); +} + +TEST(OtlpGrpcClientOptionsTest, SignalSpecificTimeoutOverridesSharedClientTimeout) +{ + ScopedEnvVar generic_timeout("OTEL_EXPORTER_OTLP_TIMEOUT", "20s"); + ScopedEnvVar traces_timeout("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT", "99s"); + + OtlpGrpcClientOptions client_options; + EXPECT_EQ(client_options.timeout, std::chrono::seconds(20)); + + OtlpGrpcExporterOptions trace_options(client_options); + EXPECT_EQ(trace_options.timeout, std::chrono::seconds(99)); +} + +TEST(OtlpGrpcClientOptionsTest, SignalWithoutSpecificOverrideFallsBackToSharedClientTimeout) +{ + ScopedEnvVar generic_timeout("OTEL_EXPORTER_OTLP_TIMEOUT", "20s"); + + OtlpGrpcClientOptions client_options; + EXPECT_EQ(client_options.timeout, std::chrono::seconds(20)); + + OtlpGrpcMetricExporterOptions metric_options(client_options); + EXPECT_EQ(metric_options.timeout, std::chrono::seconds(20)); +} + +TEST(OtlpGrpcClientOptionsTest, DerivedVoidPointerConstructorsSkipDefaults) +{ + ScopedEnvVar env("OTEL_EXPORTER_OTLP_ENDPOINT", "https://collector.example.com:4317"); + + OtlpGrpcExporterOptions trace_options(static_cast(nullptr)); + EXPECT_TRUE(trace_options.endpoint.empty()); + + OtlpGrpcMetricExporterOptions metric_options(static_cast(nullptr)); + EXPECT_TRUE(metric_options.endpoint.empty()); + + OtlpGrpcLogRecordExporterOptions log_options(static_cast(nullptr)); + EXPECT_TRUE(log_options.endpoint.empty()); +} + +} // namespace otlp +} // namespace exporter +OPENTELEMETRY_END_NAMESPACE \ No newline at end of file From 70e50e9af8b30e13a448d55be9f0795e05911161 Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Thu, 16 Jul 2026 10:16:52 +0530 Subject: [PATCH 02/12] Add missing trailing newline (fixes -Wnewline-eof in maintainer mode) Signed-off-by: Ansh Rai --- exporters/otlp/src/otlp_grpc_client_options.cc | 2 +- exporters/otlp/test/otlp_grpc_client_options_test.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/exporters/otlp/src/otlp_grpc_client_options.cc b/exporters/otlp/src/otlp_grpc_client_options.cc index 66782737b0..10fd4e4339 100644 --- a/exporters/otlp/src/otlp_grpc_client_options.cc +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -56,4 +56,4 @@ OtlpGrpcClientOptions::~OtlpGrpcClientOptions() {} } // namespace otlp } // namespace exporter -OPENTELEMETRY_END_NAMESPACE \ No newline at end of file +OPENTELEMETRY_END_NAMESPACE diff --git a/exporters/otlp/test/otlp_grpc_client_options_test.cc b/exporters/otlp/test/otlp_grpc_client_options_test.cc index 717613a002..409ed65650 100644 --- a/exporters/otlp/test/otlp_grpc_client_options_test.cc +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -135,4 +135,4 @@ TEST(OtlpGrpcClientOptionsTest, DerivedVoidPointerConstructorsSkipDefaults) } // namespace otlp } // namespace exporter -OPENTELEMETRY_END_NAMESPACE \ No newline at end of file +OPENTELEMETRY_END_NAMESPACE From 424b466a22616af25960e680dcbd43008f5235b2 Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Thu, 16 Jul 2026 18:54:12 +0000 Subject: [PATCH 03/12] Address review feedback for OtlpGrpcClientOption Signed-off-by: Ansh Rai --- .../exporters/otlp/otlp_environment.h | 235 +------- .../exporters/otlp/otlp_grpc_client_options.h | 2 +- exporters/otlp/src/otlp_environment.cc | 518 +++++++++++------- .../otlp/src/otlp_grpc_client_options.cc | 37 +- .../otlp/src/otlp_grpc_exporter_options.cc | 15 +- .../otlp_grpc_log_record_exporter_options.cc | 2 +- .../src/otlp_grpc_metric_exporter_options.cc | 2 +- 7 files changed, 361 insertions(+), 450 deletions(-) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h index 67db6ec317..03e467d51f 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h @@ -9,12 +9,7 @@ #include #include #include -#include -#include -#include "opentelemetry/common/kv_properties.h" -#include "opentelemetry/nostd/string_view.h" -#include "opentelemetry/sdk/common/env_variables.h" #include "opentelemetry/sdk/version/version.h" #include "opentelemetry/version.h" @@ -180,219 +175,23 @@ float GetOtlpDefaultLogsRetryBackoffMultiplier(); * environment variables and fall back to the same spec defaults used above. */ -inline std::string GetOtlpDefaultGrpcClientEndpoint() -{ - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4317"; - - std::string value; - - if (opentelemetry::sdk::common::GetStringEnvironmentVariable(kGenericEnv, value)) - { - return value; - } - - return kDefault; -} - -inline bool GetOtlpDefaultGrpcClientIsInsecure() -{ - std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); - - if (endpoint.substr(0, 6) == "https:") - { - return false; - } - - if (endpoint.substr(0, 5) == "http:") - { - return true; - } - - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_INSECURE"; - constexpr char kOldGenericEnv[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; - - bool insecure{}; - bool ssl_enabled{}; - - if (opentelemetry::sdk::common::GetBoolEnvironmentVariable(kGenericEnv, insecure)) - { - return insecure; - } - - if (opentelemetry::sdk::common::GetBoolEnvironmentVariable(kOldGenericEnv, ssl_enabled)) - { - return !ssl_enabled; - } - - return false; -} - -inline std::string GetOtlpDefaultGrpcClientSslCertificatePath() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CERTIFICATE", value); - return value; -} - -inline std::string GetOtlpDefaultGrpcClientSslCertificateString() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CERTIFICATE_STRING", - value); - return value; -} - -inline std::string GetOtlpDefaultGrpcClientSslClientKeyPath() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_KEY", value); - return value; -} - -inline std::string GetOtlpDefaultGrpcClientSslClientKeyString() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING", - value); - return value; -} - -inline std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", - value); - return value; -} - -inline std::string GetOtlpDefaultGrpcClientSslClientCertificateString() -{ - std::string value; - opentelemetry::sdk::common::GetStringEnvironmentVariable( - "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING", value); - return value; -} - -inline std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() -{ - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; - - std::chrono::system_clock::duration value; - - if (opentelemetry::sdk::common::GetDurationEnvironmentVariable(kGenericEnv, value)) - { - return value; - } - - return std::chrono::duration_cast(std::chrono::seconds{10}); -} - -inline OtlpHeaders GetOtlpDefaultGrpcClientHeaders() -{ - OtlpHeaders result; - - std::string raw_value; - if (!opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_HEADERS", - raw_value)) - { - return result; - } - - opentelemetry::common::KeyValueStringTokenizer tokenizer{raw_value}; - opentelemetry::nostd::string_view header_key; - opentelemetry::nostd::string_view header_value; - bool header_valid = true; - - std::unordered_set remove_cache; - - while (tokenizer.next(header_valid, header_key, header_value)) - { - if (header_valid) - { - std::string key(header_key); - if (remove_cache.end() == remove_cache.find(key)) - { - remove_cache.insert(key); - auto range = result.equal_range(key); - if (range.first != range.second) - { - result.erase(range.first, range.second); - } - } - - std::string value(header_value); - result.emplace(std::make_pair(std::move(key), std::move(value))); - } - } - - return result; -} - -inline std::string GetOtlpDefaultGrpcClientCompression() -{ - std::string value; - - if (opentelemetry::sdk::common::GetStringEnvironmentVariable("OTEL_EXPORTER_OTLP_COMPRESSION", - value)) - { - return value; - } - - return std::string{"none"}; -} - -inline std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() -{ - std::uint32_t value{}; - - if (opentelemetry::sdk::common::GetUintEnvironmentVariable( - "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS", value)) - { - return value; - } - - return 5U; -} - -inline std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() -{ - float value{}; - - if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( - "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF", value)) - { - return std::chrono::duration{value}; - } - - return std::chrono::duration{1.0f}; -} - -inline std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() -{ - float value{}; - - if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( - "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF", value)) - { - return std::chrono::duration{value}; - } - - return std::chrono::duration{5.0f}; -} - -inline float GetOtlpDefaultGrpcClientRetryBackoffMultiplier() -{ - float value{}; - - if (opentelemetry::sdk::common::GetFloatEnvironmentVariable( - "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER", value)) - { - return value; - } - - return 1.5f; -} +void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name); + +std::string GetOtlpDefaultGrpcClientEndpoint(); +bool GetOtlpDefaultGrpcClientIsInsecure(); +std::string GetOtlpDefaultGrpcClientSslCertificatePath(); +std::string GetOtlpDefaultGrpcClientSslCertificateString(); +std::string GetOtlpDefaultGrpcClientSslClientKeyPath(); +std::string GetOtlpDefaultGrpcClientSslClientKeyString(); +std::string GetOtlpDefaultGrpcClientSslClientCertificatePath(); +std::string GetOtlpDefaultGrpcClientSslClientCertificateString(); +std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout(); +OtlpHeaders GetOtlpDefaultGrpcClientHeaders(); +std::string GetOtlpDefaultGrpcClientCompression(); +std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts(); +std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff(); +std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff(); +float GetOtlpDefaultGrpcClientRetryBackoffMultiplier(); } // namespace otlp } // namespace exporter diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h index 25388f044f..0d8bce0ca6 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h @@ -22,7 +22,7 @@ namespace exporter namespace otlp { -struct OtlpGrpcClientOptions +struct OPENTELEMETRY_EXPORT OtlpGrpcClientOptions { virtual ~OtlpGrpcClientOptions(); diff --git a/exporters/otlp/src/otlp_environment.cc b/exporters/otlp/src/otlp_environment.cc index e8aae45898..4e977b24ae 100644 --- a/exporters/otlp/src/otlp_environment.cc +++ b/exporters/otlp/src/otlp_environment.cc @@ -30,6 +30,27 @@ namespace exporter namespace otlp { +constexpr char kEnvOtlpEndpoint[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; +constexpr char kEnvOtlpInsecure[] = "OTEL_EXPORTER_OTLP_INSECURE"; +constexpr char kEnvOtlpSslEnable[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; +constexpr char kEnvOtlpCertificate[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; +constexpr char kEnvOtlpCertificateString[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; +constexpr char kEnvOtlpClientKey[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; +constexpr char kEnvOtlpClientKeyString[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; +constexpr char kEnvOtlpClientCertificate[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; +constexpr char kEnvOtlpClientCertificateString[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; +constexpr char kEnvOtlpTimeout[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; +constexpr char kEnvOtlpHeaders[] = "OTEL_EXPORTER_OTLP_HEADERS"; +constexpr char kEnvOtlpCompression[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; +constexpr char kEnvOtlpRetryMaxAttempts[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; +constexpr char kEnvOtlpRetryInitialBackoff[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; +constexpr char kEnvOtlpRetryMaxBackoff[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; +constexpr char kEnvOtlpRetryBackoffMultiplier[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; +constexpr char kEnvOtlpMinTls[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; +constexpr char kEnvOtlpMaxTls[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; +constexpr char kEnvOtlpCipher[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; +constexpr char kEnvOtlpCipherSuite[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; + static bool GetBoolDualEnvVar(const char *signal_name, const char *generic_name, bool &value) { bool exists{}; @@ -113,14 +134,13 @@ static bool GetFloatDualEnvVar(const char *signal_name, const char *generic_name std::string GetOtlpDefaultGrpcTracesEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4317"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4317"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpEndpoint, value); if (exists) { @@ -132,14 +152,13 @@ std::string GetOtlpDefaultGrpcTracesEndpoint() std::string GetOtlpDefaultGrpcMetricsEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4317"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4317"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpEndpoint, value); if (exists) { @@ -151,14 +170,13 @@ std::string GetOtlpDefaultGrpcMetricsEndpoint() std::string GetOtlpDefaultGrpcLogsEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4317"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4317"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpEndpoint, value); if (exists) { @@ -170,9 +188,8 @@ std::string GetOtlpDefaultGrpcLogsEndpoint() std::string GetOtlpDefaultHttpTracesEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4318/v1/traces"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4318/v1/traces"; std::string value; bool exists{}; @@ -183,7 +200,7 @@ std::string GetOtlpDefaultHttpTracesEndpoint() return value; } - exists = sdk_common::GetStringEnvironmentVariable(kGenericEnv, value); + exists = sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value); if (exists) { value += "/v1/traces"; @@ -195,9 +212,8 @@ std::string GetOtlpDefaultHttpTracesEndpoint() std::string GetOtlpDefaultHttpMetricsEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4318/v1/metrics"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4318/v1/metrics"; std::string value; bool exists{}; @@ -208,7 +224,7 @@ std::string GetOtlpDefaultHttpMetricsEndpoint() return value; } - exists = sdk_common::GetStringEnvironmentVariable(kGenericEnv, value); + exists = sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value); if (exists) { value += "/v1/metrics"; @@ -220,9 +236,8 @@ std::string GetOtlpDefaultHttpMetricsEndpoint() std::string GetOtlpDefaultHttpLogsEndpoint() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; - constexpr char kDefault[] = "http://localhost:4318/v1/logs"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"; + constexpr char kDefault[] = "http://localhost:4318/v1/logs"; std::string value; bool exists{}; @@ -233,7 +248,7 @@ std::string GetOtlpDefaultHttpLogsEndpoint() return value; } - exists = sdk_common::GetStringEnvironmentVariable(kGenericEnv, value); + exists = sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value); if (exists) { value += "/v1/logs"; @@ -331,16 +346,14 @@ bool GetOtlpDefaultGrpcTracesIsInsecure() return true; } - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_INSECURE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_INSECURE"; - constexpr char kOldSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_SSL_ENABLE"; - constexpr char kOldGenericEnv[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_INSECURE"; + constexpr char kOldSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_SSL_ENABLE"; bool insecure{}; bool ssl_enabled{}; bool exists{}; - exists = GetBoolDualEnvVar(kSignalEnv, kGenericEnv, insecure); + exists = GetBoolDualEnvVar(kSignalEnv, kEnvOtlpInsecure, insecure); if (exists) { return insecure; @@ -358,12 +371,12 @@ bool GetOtlpDefaultGrpcTracesIsInsecure() return insecure; } - exists = sdk_common::GetBoolEnvironmentVariable(kOldGenericEnv, ssl_enabled); + exists = sdk_common::GetBoolEnvironmentVariable(kEnvOtlpSslEnable, ssl_enabled); if (exists) { #ifdef WARN_DEPRECATED_ENV - OTEL_INTERNAL_LOG_WARN("Environment variable <" << kOldGenericEnv << "> is deprecated, use <" - << kGenericEnv << "> instead."); + OTEL_INTERNAL_LOG_WARN("Environment variable <" << kEnvOtlpSslEnable << "> is deprecated, use <" + << kEnvOtlpInsecure << "> instead."); #endif insecure = !ssl_enabled; @@ -389,16 +402,14 @@ bool GetOtlpDefaultGrpcMetricsIsInsecure() return true; } - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_INSECURE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_INSECURE"; - constexpr char kOldSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_SSL_ENABLE"; - constexpr char kOldGenericEnv[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_INSECURE"; + constexpr char kOldSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_SSL_ENABLE"; bool insecure{}; bool ssl_enabled{}; bool exists{}; - exists = GetBoolDualEnvVar(kSignalEnv, kGenericEnv, insecure); + exists = GetBoolDualEnvVar(kSignalEnv, kEnvOtlpInsecure, insecure); if (exists) { return insecure; @@ -416,12 +427,12 @@ bool GetOtlpDefaultGrpcMetricsIsInsecure() return insecure; } - exists = sdk_common::GetBoolEnvironmentVariable(kOldGenericEnv, ssl_enabled); + exists = sdk_common::GetBoolEnvironmentVariable(kEnvOtlpSslEnable, ssl_enabled); if (exists) { #ifdef WARN_DEPRECATED_ENV - OTEL_INTERNAL_LOG_WARN("Environment variable <" << kOldGenericEnv << "> is deprecated, use <" - << kGenericEnv << "> instead."); + OTEL_INTERNAL_LOG_WARN("Environment variable <" << kEnvOtlpSslEnable << "> is deprecated, use <" + << kEnvOtlpInsecure << "> instead."); #endif insecure = !ssl_enabled; @@ -447,13 +458,12 @@ bool GetOtlpDefaultGrpcLogsIsInsecure() return true; } - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_INSECURE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_INSECURE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_INSECURE"; bool insecure{}; bool exists{}; - exists = GetBoolDualEnvVar(kSignalEnv, kGenericEnv, insecure); + exists = GetBoolDualEnvVar(kSignalEnv, kEnvOtlpInsecure, insecure); if (exists) { return insecure; @@ -464,13 +474,12 @@ bool GetOtlpDefaultGrpcLogsIsInsecure() std::string GetOtlpDefaultTracesSslCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificate, value); if (exists) { return value; @@ -481,13 +490,12 @@ std::string GetOtlpDefaultTracesSslCertificatePath() std::string GetOtlpDefaultMetricsSslCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificate, value); if (exists) { return value; @@ -498,13 +506,12 @@ std::string GetOtlpDefaultMetricsSslCertificatePath() std::string GetOtlpDefaultLogsSslCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificate, value); if (exists) { return value; @@ -515,13 +522,12 @@ std::string GetOtlpDefaultLogsSslCertificatePath() std::string GetOtlpDefaultTracesSslCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificateString, value); if (exists) { return value; @@ -532,13 +538,12 @@ std::string GetOtlpDefaultTracesSslCertificateString() std::string GetOtlpDefaultMetricsSslCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificateString, value); if (exists) { return value; @@ -549,13 +554,12 @@ std::string GetOtlpDefaultMetricsSslCertificateString() std::string GetOtlpDefaultLogsSslCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCertificateString, value); if (exists) { return value; @@ -566,13 +570,12 @@ std::string GetOtlpDefaultLogsSslCertificateString() std::string GetOtlpDefaultTracesSslClientKeyPath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKey, value); if (exists) { return value; @@ -583,13 +586,12 @@ std::string GetOtlpDefaultTracesSslClientKeyPath() std::string GetOtlpDefaultMetricsSslClientKeyPath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKey, value); if (exists) { return value; @@ -600,13 +602,12 @@ std::string GetOtlpDefaultMetricsSslClientKeyPath() std::string GetOtlpDefaultLogsSslClientKeyPath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKey, value); if (exists) { return value; @@ -617,13 +618,12 @@ std::string GetOtlpDefaultLogsSslClientKeyPath() std::string GetOtlpDefaultTracesSslClientKeyString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKeyString, value); if (exists) { return value; @@ -634,13 +634,12 @@ std::string GetOtlpDefaultTracesSslClientKeyString() std::string GetOtlpDefaultMetricsSslClientKeyString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKeyString, value); if (exists) { return value; @@ -651,13 +650,12 @@ std::string GetOtlpDefaultMetricsSslClientKeyString() std::string GetOtlpDefaultLogsSslClientKeyString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientKeyString, value); if (exists) { return value; @@ -668,13 +666,12 @@ std::string GetOtlpDefaultLogsSslClientKeyString() std::string GetOtlpDefaultTracesSslClientCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificate, value); if (exists) { return value; @@ -685,13 +682,12 @@ std::string GetOtlpDefaultTracesSslClientCertificatePath() std::string GetOtlpDefaultMetricsSslClientCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificate, value); if (exists) { return value; @@ -702,13 +698,12 @@ std::string GetOtlpDefaultMetricsSslClientCertificatePath() std::string GetOtlpDefaultLogsSslClientCertificatePath() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificate, value); if (exists) { return value; @@ -719,13 +714,12 @@ std::string GetOtlpDefaultLogsSslClientCertificatePath() std::string GetOtlpDefaultTracesSslClientCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificateString, value); if (exists) { return value; @@ -736,13 +730,12 @@ std::string GetOtlpDefaultTracesSslClientCertificateString() std::string GetOtlpDefaultMetricsSslClientCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificateString, value); if (exists) { return value; @@ -753,13 +746,12 @@ std::string GetOtlpDefaultMetricsSslClientCertificateString() std::string GetOtlpDefaultLogsSslClientCertificateString() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE_STRING"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE_STRING"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpClientCertificateString, value); if (exists) { return value; @@ -776,13 +768,12 @@ std::string GetOtlpDefaultLogsSslClientCertificateString() std::string GetOtlpDefaultTracesSslTlsMinVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_MIN_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_MIN_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMinTls, value); if (exists) { return value; @@ -793,13 +784,12 @@ std::string GetOtlpDefaultTracesSslTlsMinVersion() std::string GetOtlpDefaultMetricsSslTlsMinVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_MIN_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_MIN_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMinTls, value); if (exists) { return value; @@ -810,13 +800,12 @@ std::string GetOtlpDefaultMetricsSslTlsMinVersion() std::string GetOtlpDefaultLogsSslTlsMinVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_MIN_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_MIN_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMinTls, value); if (exists) { return value; @@ -827,13 +816,12 @@ std::string GetOtlpDefaultLogsSslTlsMinVersion() std::string GetOtlpDefaultTracesSslTlsMaxVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_MAX_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_MAX_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMaxTls, value); if (exists) { return value; @@ -844,13 +832,12 @@ std::string GetOtlpDefaultTracesSslTlsMaxVersion() std::string GetOtlpDefaultMetricsSslTlsMaxVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_MAX_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_MAX_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMaxTls, value); if (exists) { return value; @@ -861,13 +848,12 @@ std::string GetOtlpDefaultMetricsSslTlsMaxVersion() std::string GetOtlpDefaultLogsSslTlsMaxVersion() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_MAX_TLS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_MAX_TLS"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpMaxTls, value); if (exists) { return value; @@ -878,13 +864,12 @@ std::string GetOtlpDefaultLogsSslTlsMaxVersion() std::string GetOtlpDefaultTracesSslTlsCipher() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_CIPHER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_CIPHER"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipher, value); if (exists) { return value; @@ -895,13 +880,12 @@ std::string GetOtlpDefaultTracesSslTlsCipher() std::string GetOtlpDefaultMetricsSslTlsCipher() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_CIPHER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_CIPHER"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipher, value); if (exists) { return value; @@ -912,13 +896,12 @@ std::string GetOtlpDefaultMetricsSslTlsCipher() std::string GetOtlpDefaultLogsSslTlsCipher() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_CIPHER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_CIPHER"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipher, value); if (exists) { return value; @@ -929,13 +912,12 @@ std::string GetOtlpDefaultLogsSslTlsCipher() std::string GetOtlpDefaultTracesSslTlsCipherSuite() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_CIPHER_SUITE"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_CIPHER_SUITE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipherSuite, value); if (exists) { return value; @@ -946,13 +928,12 @@ std::string GetOtlpDefaultTracesSslTlsCipherSuite() std::string GetOtlpDefaultMetricsSslTlsCipherSuite() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_CIPHER_SUITE"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_CIPHER_SUITE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipherSuite, value); if (exists) { return value; @@ -963,13 +944,12 @@ std::string GetOtlpDefaultMetricsSslTlsCipherSuite() std::string GetOtlpDefaultLogsSslTlsCipherSuite() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_CIPHER_SUITE"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_CIPHER_SUITE"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCipherSuite, value); if (exists) { return value; @@ -980,13 +960,12 @@ std::string GetOtlpDefaultLogsSslTlsCipherSuite() std::chrono::system_clock::duration GetOtlpDefaultTracesTimeout() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT"; std::chrono::system_clock::duration value; bool exists{}; - exists = GetDurationDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetDurationDualEnvVar(kSignalEnv, kEnvOtlpTimeout, value); if (exists) { return value; @@ -998,13 +977,12 @@ std::chrono::system_clock::duration GetOtlpDefaultTracesTimeout() std::chrono::system_clock::duration GetOtlpDefaultMetricsTimeout() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT"; std::chrono::system_clock::duration value; bool exists{}; - exists = GetDurationDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetDurationDualEnvVar(kSignalEnv, kEnvOtlpTimeout, value); if (exists) { return value; @@ -1016,13 +994,12 @@ std::chrono::system_clock::duration GetOtlpDefaultMetricsTimeout() std::chrono::system_clock::duration GetOtlpDefaultLogsTimeout() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT"; std::chrono::system_clock::duration value; bool exists{}; - exists = GetDurationDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetDurationDualEnvVar(kSignalEnv, kEnvOtlpTimeout, value); if (exists) { return value; @@ -1032,7 +1009,7 @@ std::chrono::system_clock::duration GetOtlpDefaultLogsTimeout() return value; } -static void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name) +void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name) { std::string raw_value; bool exists{}; @@ -1083,37 +1060,33 @@ static OtlpHeaders GetHeaders(const char *signal_name, const char *generic_name) OtlpHeaders GetOtlpDefaultTracesHeaders() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_HEADERS"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_HEADERS"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_HEADERS"; - return GetHeaders(kSignalEnv, kGenericEnv); + return GetHeaders(kSignalEnv, kEnvOtlpHeaders); } OtlpHeaders GetOtlpDefaultMetricsHeaders() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_HEADERS"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_HEADERS"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_HEADERS"; - return GetHeaders(kSignalEnv, kGenericEnv); + return GetHeaders(kSignalEnv, kEnvOtlpHeaders); } OtlpHeaders GetOtlpDefaultLogsHeaders() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_HEADERS"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_HEADERS"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_HEADERS"; - return GetHeaders(kSignalEnv, kGenericEnv); + return GetHeaders(kSignalEnv, kEnvOtlpHeaders); } std::string GetOtlpDefaultTracesCompression() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_COMPRESSION"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_COMPRESSION"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCompression, value); if (exists) { return value; @@ -1124,13 +1097,12 @@ std::string GetOtlpDefaultTracesCompression() std::string GetOtlpDefaultMetricsCompression() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_COMPRESSION"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_COMPRESSION"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCompression, value); if (exists) { return value; @@ -1141,13 +1113,12 @@ std::string GetOtlpDefaultMetricsCompression() std::string GetOtlpDefaultLogsCompression() { - constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_COMPRESSION"; - constexpr char kGenericEnv[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_COMPRESSION"; std::string value; bool exists{}; - exists = GetStringDualEnvVar(kSignalEnv, kGenericEnv, value); + exists = GetStringDualEnvVar(kSignalEnv, kEnvOtlpCompression, value); if (exists) { return value; @@ -1158,11 +1129,10 @@ std::string GetOtlpDefaultLogsCompression() std::uint32_t GetOtlpDefaultTracesRetryMaxAttempts() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_MAX_ATTEMPTS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_MAX_ATTEMPTS"; std::uint32_t value{}; - if (GetUintDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetUintDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxAttempts, value)) { return value; } @@ -1172,11 +1142,10 @@ std::uint32_t GetOtlpDefaultTracesRetryMaxAttempts() std::uint32_t GetOtlpDefaultMetricsRetryMaxAttempts() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_MAX_ATTEMPTS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_MAX_ATTEMPTS"; std::uint32_t value{}; - if (GetUintDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetUintDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxAttempts, value)) { return value; } @@ -1186,11 +1155,10 @@ std::uint32_t GetOtlpDefaultMetricsRetryMaxAttempts() std::uint32_t GetOtlpDefaultLogsRetryMaxAttempts() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_MAX_ATTEMPTS"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_MAX_ATTEMPTS"; std::uint32_t value{}; - if (GetUintDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetUintDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxAttempts, value)) { return value; } @@ -1200,11 +1168,10 @@ std::uint32_t GetOtlpDefaultLogsRetryMaxAttempts() std::chrono::duration GetOtlpDefaultTracesRetryInitialBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_INITIAL_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_INITIAL_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryInitialBackoff, value)) { return std::chrono::duration{value}; } @@ -1214,11 +1181,10 @@ std::chrono::duration GetOtlpDefaultTracesRetryInitialBackoff() std::chrono::duration GetOtlpDefaultMetricsRetryInitialBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_INITIAL_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_INITIAL_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryInitialBackoff, value)) { return std::chrono::duration{value}; } @@ -1228,11 +1194,10 @@ std::chrono::duration GetOtlpDefaultMetricsRetryInitialBackoff() std::chrono::duration GetOtlpDefaultLogsRetryInitialBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_INITIAL_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_INITIAL_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryInitialBackoff, value)) { return std::chrono::duration{value}; } @@ -1242,11 +1207,10 @@ std::chrono::duration GetOtlpDefaultLogsRetryInitialBackoff() std::chrono::duration GetOtlpDefaultTracesRetryMaxBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_MAX_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_MAX_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxBackoff, value)) { return std::chrono::duration{value}; } @@ -1256,11 +1220,10 @@ std::chrono::duration GetOtlpDefaultTracesRetryMaxBackoff() std::chrono::duration GetOtlpDefaultMetricsRetryMaxBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_MAX_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_MAX_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxBackoff, value)) { return std::chrono::duration{value}; } @@ -1270,11 +1233,10 @@ std::chrono::duration GetOtlpDefaultMetricsRetryMaxBackoff() std::chrono::duration GetOtlpDefaultLogsRetryMaxBackoff() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_MAX_BACKOFF"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_MAX_BACKOFF"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryMaxBackoff, value)) { return std::chrono::duration{value}; } @@ -1284,11 +1246,10 @@ std::chrono::duration GetOtlpDefaultLogsRetryMaxBackoff() float GetOtlpDefaultTracesRetryBackoffMultiplier() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_BACKOFF_MULTIPLIER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_TRACES_RETRY_BACKOFF_MULTIPLIER"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryBackoffMultiplier, value)) { return value; } @@ -1298,11 +1259,10 @@ float GetOtlpDefaultTracesRetryBackoffMultiplier() float GetOtlpDefaultMetricsRetryBackoffMultiplier() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_BACKOFF_MULTIPLIER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_METRICS_RETRY_BACKOFF_MULTIPLIER"; float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryBackoffMultiplier, value)) { return value; } @@ -1312,11 +1272,175 @@ float GetOtlpDefaultMetricsRetryBackoffMultiplier() float GetOtlpDefaultLogsRetryBackoffMultiplier() { - constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_BACKOFF_MULTIPLIER"; - constexpr char kGenericEnv[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; + constexpr char kSignalEnv[] = "OTEL_CPP_EXPORTER_OTLP_LOGS_RETRY_BACKOFF_MULTIPLIER"; + float value{}; + + if (GetFloatDualEnvVar(kSignalEnv, kEnvOtlpRetryBackoffMultiplier, value)) + { + return value; + } + + return 1.5f; +} + +std::string GetOtlpDefaultGrpcClientEndpoint() +{ + constexpr char kDefault[] = "http://localhost:4317"; + + std::string value; + + if (sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value)) + { + return value; + } + + return kDefault; +} + +bool GetOtlpDefaultGrpcClientIsInsecure() +{ + std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); + + if (endpoint.substr(0, 6) == "https:") + { + return false; + } + + if (endpoint.substr(0, 5) == "http:") + { + return true; + } + + bool insecure{}; + bool ssl_enabled{}; + + if (sdk_common::GetBoolEnvironmentVariable(kEnvOtlpInsecure, insecure)) + { + return insecure; + } + + if (sdk_common::GetBoolEnvironmentVariable(kEnvOtlpSslEnable, ssl_enabled)) + { + return !ssl_enabled; + } + + return false; +} + +std::string GetOtlpDefaultGrpcClientSslCertificatePath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificate, value); + return value; +} + +std::string GetOtlpDefaultGrpcClientSslCertificateString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificateString, value); + return value; +} + +std::string GetOtlpDefaultGrpcClientSslClientKeyPath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKey, value); + return value; +} + +std::string GetOtlpDefaultGrpcClientSslClientKeyString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKeyString, value); + return value; +} + +std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificate, value); + return value; +} + +std::string GetOtlpDefaultGrpcClientSslClientCertificateString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificateString, value); + return value; +} + +std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() +{ + std::chrono::system_clock::duration value; + + if (sdk_common::GetDurationEnvironmentVariable(kEnvOtlpTimeout, value)) + { + return value; + } + + return std::chrono::duration_cast(std::chrono::seconds{10}); +} + +OtlpHeaders GetOtlpDefaultGrpcClientHeaders() +{ + OtlpHeaders result; + DumpOtlpHeaders(result, kEnvOtlpHeaders); + return result; +} + +std::string GetOtlpDefaultGrpcClientCompression() +{ + std::string value; + + if (sdk_common::GetStringEnvironmentVariable(kEnvOtlpCompression, value)) + { + return value; + } + + return std::string{"none"}; +} + +std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() +{ + std::uint32_t value{}; + + if (sdk_common::GetUintEnvironmentVariable(kEnvOtlpRetryMaxAttempts, value)) + { + return value; + } + + return 5U; +} + +std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() +{ + float value{}; + + if (sdk_common::GetFloatEnvironmentVariable(kEnvOtlpRetryInitialBackoff, value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{1.0f}; +} + +std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() +{ + float value{}; + + if (sdk_common::GetFloatEnvironmentVariable(kEnvOtlpRetryMaxBackoff, value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{5.0f}; +} + +float GetOtlpDefaultGrpcClientRetryBackoffMultiplier() +{ float value{}; - if (GetFloatDualEnvVar(kSignalEnv, kGenericEnv, value)) + if (sdk_common::GetFloatEnvironmentVariable(kEnvOtlpRetryBackoffMultiplier, value)) { return value; } diff --git a/exporters/otlp/src/otlp_grpc_client_options.cc b/exporters/otlp/src/otlp_grpc_client_options.cc index 10fd4e4339..46660d542b 100644 --- a/exporters/otlp/src/otlp_grpc_client_options.cc +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -12,34 +12,29 @@ namespace otlp { OtlpGrpcClientOptions::OtlpGrpcClientOptions() + : endpoint(GetOtlpDefaultGrpcClientEndpoint()), + use_ssl_credentials(!GetOtlpDefaultGrpcClientIsInsecure()), + ssl_credentials_cacert_path(GetOtlpDefaultGrpcClientSslCertificatePath()), + ssl_credentials_cacert_as_string(GetOtlpDefaultGrpcClientSslCertificateString()), + timeout(GetOtlpDefaultGrpcClientTimeout()), + metadata(GetOtlpDefaultGrpcClientHeaders()), + user_agent(GetOtlpDefaultUserAgent()), + max_threads(0), + compression(GetOtlpDefaultGrpcClientCompression()), +#ifdef ENABLE_ASYNC_EXPORT + max_concurrent_requests(64), +#endif + retry_policy_max_attempts(GetOtlpDefaultGrpcClientRetryMaxAttempts()), + retry_policy_initial_backoff(GetOtlpDefaultGrpcClientRetryInitialBackoff()), + retry_policy_max_backoff(GetOtlpDefaultGrpcClientRetryMaxBackoff()), + retry_policy_backoff_multiplier(GetOtlpDefaultGrpcClientRetryBackoffMultiplier()) { - endpoint = GetOtlpDefaultGrpcClientEndpoint(); - use_ssl_credentials = !GetOtlpDefaultGrpcClientIsInsecure(); - ssl_credentials_cacert_path = GetOtlpDefaultGrpcClientSslCertificatePath(); - ssl_credentials_cacert_as_string = GetOtlpDefaultGrpcClientSslCertificateString(); - #ifdef ENABLE_OTLP_GRPC_SSL_MTLS_PREVIEW ssl_client_key_path = GetOtlpDefaultGrpcClientSslClientKeyPath(); ssl_client_key_string = GetOtlpDefaultGrpcClientSslClientKeyString(); ssl_client_cert_path = GetOtlpDefaultGrpcClientSslClientCertificatePath(); ssl_client_cert_string = GetOtlpDefaultGrpcClientSslClientCertificateString(); #endif - - timeout = GetOtlpDefaultGrpcClientTimeout(); - metadata = GetOtlpDefaultGrpcClientHeaders(); - user_agent = GetOtlpDefaultUserAgent(); - - max_threads = 0; - - compression = GetOtlpDefaultGrpcClientCompression(); -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif - - retry_policy_max_attempts = GetOtlpDefaultGrpcClientRetryMaxAttempts(); - retry_policy_initial_backoff = GetOtlpDefaultGrpcClientRetryInitialBackoff(); - retry_policy_max_backoff = GetOtlpDefaultGrpcClientRetryMaxBackoff(); - retry_policy_backoff_multiplier = GetOtlpDefaultGrpcClientRetryBackoffMultiplier(); } OtlpGrpcClientOptions::OtlpGrpcClientOptions(void *) diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 82b229c9db..c374938149 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -14,7 +14,7 @@ namespace exporter namespace otlp { -OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() : OtlpGrpcClientOptions() { endpoint = GetOtlpDefaultGrpcTracesEndpoint(); use_ssl_credentials = !GetOtlpDefaultGrpcTracesIsInsecure(); /* negation intended. */ @@ -28,16 +28,9 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() ssl_client_cert_string = GetOtlpDefaultTracesSslClientCertificateString(); #endif - timeout = GetOtlpDefaultTracesTimeout(); - metadata = GetOtlpDefaultTracesHeaders(); - user_agent = GetOtlpDefaultUserAgent(); - - max_threads = 0; - + timeout = GetOtlpDefaultTracesTimeout(); + metadata = GetOtlpDefaultTracesHeaders(); compression = GetOtlpDefaultTracesCompression(); -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif retry_policy_max_attempts = GetOtlpDefaultTracesRetryMaxAttempts(); retry_policy_initial_backoff = GetOtlpDefaultTracesRetryInitialBackoff(); @@ -62,7 +55,7 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &cl metadata = GetOtlpDefaultTracesHeaders(); #ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; + max_concurrent_requests = client_options.max_concurrent_requests; #endif } diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index 4b2669ea08..4978a73994 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -64,7 +64,7 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( metadata = GetOtlpDefaultLogsHeaders(); #ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; + max_concurrent_requests = client_options.max_concurrent_requests; #endif } diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index b9b40eaaca..03c9c574af 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -68,7 +68,7 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( metadata = GetOtlpDefaultMetricsHeaders(); #ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; + max_concurrent_requests = client_options.max_concurrent_requests; #endif } From 2ca8d8e2bdd634af7afb1f54da8e12585632d286 Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Mon, 20 Jul 2026 00:09:53 +0530 Subject: [PATCH 04/12] Address remaining review feedback Signed-off-by: Ansh Rai --- exporters/otlp/src/otlp_environment.cc | 51 ++++++++++++++------------ 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/exporters/otlp/src/otlp_environment.cc b/exporters/otlp/src/otlp_environment.cc index 4e977b24ae..bc8fb3c594 100644 --- a/exporters/otlp/src/otlp_environment.cc +++ b/exporters/otlp/src/otlp_environment.cc @@ -30,26 +30,29 @@ namespace exporter namespace otlp { -constexpr char kEnvOtlpEndpoint[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; -constexpr char kEnvOtlpInsecure[] = "OTEL_EXPORTER_OTLP_INSECURE"; -constexpr char kEnvOtlpSslEnable[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; -constexpr char kEnvOtlpCertificate[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; -constexpr char kEnvOtlpCertificateString[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; -constexpr char kEnvOtlpClientKey[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; -constexpr char kEnvOtlpClientKeyString[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; -constexpr char kEnvOtlpClientCertificate[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; -constexpr char kEnvOtlpClientCertificateString[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; -constexpr char kEnvOtlpTimeout[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; -constexpr char kEnvOtlpHeaders[] = "OTEL_EXPORTER_OTLP_HEADERS"; -constexpr char kEnvOtlpCompression[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; -constexpr char kEnvOtlpRetryMaxAttempts[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; -constexpr char kEnvOtlpRetryInitialBackoff[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; -constexpr char kEnvOtlpRetryMaxBackoff[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; -constexpr char kEnvOtlpRetryBackoffMultiplier[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; -constexpr char kEnvOtlpMinTls[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; -constexpr char kEnvOtlpMaxTls[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; -constexpr char kEnvOtlpCipher[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; -constexpr char kEnvOtlpCipherSuite[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; +static constexpr char kEnvOtlpEndpoint[] = "OTEL_EXPORTER_OTLP_ENDPOINT"; +static constexpr char kEnvOtlpInsecure[] = "OTEL_EXPORTER_OTLP_INSECURE"; +static constexpr char kEnvOtlpSslEnable[] = "OTEL_EXPORTER_OTLP_SSL_ENABLE"; +static constexpr char kEnvOtlpCertificate[] = "OTEL_EXPORTER_OTLP_CERTIFICATE"; +static constexpr char kEnvOtlpCertificateString[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING"; +static constexpr char kEnvOtlpClientKey[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY"; +static constexpr char kEnvOtlpClientKeyString[] = "OTEL_EXPORTER_OTLP_CLIENT_KEY_STRING"; +static constexpr char kEnvOtlpClientCertificate[] = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE"; +static constexpr char kEnvOtlpClientCertificateString[] = + "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_STRING"; +static constexpr char kEnvOtlpTimeout[] = "OTEL_EXPORTER_OTLP_TIMEOUT"; +static constexpr char kEnvOtlpHeaders[] = "OTEL_EXPORTER_OTLP_HEADERS"; +static constexpr char kEnvOtlpCompression[] = "OTEL_EXPORTER_OTLP_COMPRESSION"; +static constexpr char kEnvOtlpRetryMaxAttempts[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_ATTEMPTS"; +static constexpr char kEnvOtlpRetryInitialBackoff[] = + "OTEL_CPP_EXPORTER_OTLP_RETRY_INITIAL_BACKOFF"; +static constexpr char kEnvOtlpRetryMaxBackoff[] = "OTEL_CPP_EXPORTER_OTLP_RETRY_MAX_BACKOFF"; +static constexpr char kEnvOtlpRetryBackoffMultiplier[] = + "OTEL_CPP_EXPORTER_OTLP_RETRY_BACKOFF_MULTIPLIER"; +static constexpr char kEnvOtlpMinTls[] = "OTEL_CPP_EXPORTER_OTLP_MIN_TLS"; +static constexpr char kEnvOtlpMaxTls[] = "OTEL_CPP_EXPORTER_OTLP_MAX_TLS"; +static constexpr char kEnvOtlpCipher[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER"; +static constexpr char kEnvOtlpCipherSuite[] = "OTEL_CPP_EXPORTER_OTLP_CIPHER_SUITE"; static bool GetBoolDualEnvVar(const char *signal_name, const char *generic_name, bool &value) { @@ -336,7 +339,7 @@ bool GetOtlpDefaultGrpcTracesIsInsecure() /* The trace endpoint, when providing a scheme, takes precedence. */ - if (endpoint.substr(0, 6) == "https:") + if (opentelemetry::nostd::string_view(endpoint).substr(0, 6) == "https:") { return false; } @@ -392,7 +395,7 @@ bool GetOtlpDefaultGrpcMetricsIsInsecure() /* The metrics endpoint, when providing a scheme, takes precedence. */ - if (endpoint.substr(0, 6) == "https:") + if (opentelemetry::nostd::string_view(endpoint).substr(0, 6) == "https:") { return false; } @@ -448,7 +451,7 @@ bool GetOtlpDefaultGrpcLogsIsInsecure() /* The logs endpoint, when providing a scheme, takes precedence. */ - if (endpoint.substr(0, 6) == "https:") + if (opentelemetry::nostd::string_view(endpoint).substr(0, 6) == "https:") { return false; } @@ -1301,7 +1304,7 @@ bool GetOtlpDefaultGrpcClientIsInsecure() { std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); - if (endpoint.substr(0, 6) == "https:") + if (opentelemetry::nostd::string_view(endpoint).substr(0, 6) == "https:") { return false; } From b2627caf792f8a449b8b87c5aa34804ad3255dbb Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Mon, 20 Jul 2026 21:16:33 +0530 Subject: [PATCH 05/12] Export generic gRPC client environment helpers Signed-off-by: Ansh Rai --- .../exporters/otlp/otlp_environment.h | 30 +++++++++---------- exporters/otlp/src/otlp_environment.cc | 30 +++++++++---------- 2 files changed, 30 insertions(+), 30 deletions(-) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h index 03e467d51f..ac193a4f75 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h @@ -177,21 +177,21 @@ float GetOtlpDefaultLogsRetryBackoffMultiplier(); void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name); -std::string GetOtlpDefaultGrpcClientEndpoint(); -bool GetOtlpDefaultGrpcClientIsInsecure(); -std::string GetOtlpDefaultGrpcClientSslCertificatePath(); -std::string GetOtlpDefaultGrpcClientSslCertificateString(); -std::string GetOtlpDefaultGrpcClientSslClientKeyPath(); -std::string GetOtlpDefaultGrpcClientSslClientKeyString(); -std::string GetOtlpDefaultGrpcClientSslClientCertificatePath(); -std::string GetOtlpDefaultGrpcClientSslClientCertificateString(); -std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout(); -OtlpHeaders GetOtlpDefaultGrpcClientHeaders(); -std::string GetOtlpDefaultGrpcClientCompression(); -std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts(); -std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff(); -std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff(); -float GetOtlpDefaultGrpcClientRetryBackoffMultiplier(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientEndpoint(); +OPENTELEMETRY_EXPORT bool GetOtlpDefaultGrpcClientIsInsecure(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificatePath(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificateString(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyPath(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyString(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificatePath(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificateString(); +OPENTELEMETRY_EXPORT std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout(); +OPENTELEMETRY_EXPORT OtlpHeaders GetOtlpDefaultGrpcClientHeaders(); +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientCompression(); +OPENTELEMETRY_EXPORT std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts(); +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff(); +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff(); +OPENTELEMETRY_EXPORT float GetOtlpDefaultGrpcClientRetryBackoffMultiplier(); } // namespace otlp } // namespace exporter diff --git a/exporters/otlp/src/otlp_environment.cc b/exporters/otlp/src/otlp_environment.cc index bc8fb3c594..7fd92da15c 100644 --- a/exporters/otlp/src/otlp_environment.cc +++ b/exporters/otlp/src/otlp_environment.cc @@ -1286,7 +1286,7 @@ float GetOtlpDefaultLogsRetryBackoffMultiplier() return 1.5f; } -std::string GetOtlpDefaultGrpcClientEndpoint() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientEndpoint() { constexpr char kDefault[] = "http://localhost:4317"; @@ -1300,7 +1300,7 @@ std::string GetOtlpDefaultGrpcClientEndpoint() return kDefault; } -bool GetOtlpDefaultGrpcClientIsInsecure() +OPENTELEMETRY_EXPORT bool GetOtlpDefaultGrpcClientIsInsecure() { std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); @@ -1330,49 +1330,49 @@ bool GetOtlpDefaultGrpcClientIsInsecure() return false; } -std::string GetOtlpDefaultGrpcClientSslCertificatePath() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificatePath() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificate, value); return value; } -std::string GetOtlpDefaultGrpcClientSslCertificateString() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificateString() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificateString, value); return value; } -std::string GetOtlpDefaultGrpcClientSslClientKeyPath() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyPath() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKey, value); return value; } -std::string GetOtlpDefaultGrpcClientSslClientKeyString() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyString() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKeyString, value); return value; } -std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificate, value); return value; } -std::string GetOtlpDefaultGrpcClientSslClientCertificateString() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificateString() { std::string value; sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificateString, value); return value; } -std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() +OPENTELEMETRY_EXPORT std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() { std::chrono::system_clock::duration value; @@ -1384,14 +1384,14 @@ std::chrono::system_clock::duration GetOtlpDefaultGrpcClientTimeout() return std::chrono::duration_cast(std::chrono::seconds{10}); } -OtlpHeaders GetOtlpDefaultGrpcClientHeaders() +OPENTELEMETRY_EXPORT OtlpHeaders GetOtlpDefaultGrpcClientHeaders() { OtlpHeaders result; DumpOtlpHeaders(result, kEnvOtlpHeaders); return result; } -std::string GetOtlpDefaultGrpcClientCompression() +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientCompression() { std::string value; @@ -1403,7 +1403,7 @@ std::string GetOtlpDefaultGrpcClientCompression() return std::string{"none"}; } -std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() +OPENTELEMETRY_EXPORT std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() { std::uint32_t value{}; @@ -1415,7 +1415,7 @@ std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() return 5U; } -std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() { float value{}; @@ -1427,7 +1427,7 @@ std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() return std::chrono::duration{1.0f}; } -std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() { float value{}; @@ -1439,7 +1439,7 @@ std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() return std::chrono::duration{5.0f}; } -float GetOtlpDefaultGrpcClientRetryBackoffMultiplier() +OPENTELEMETRY_EXPORT float GetOtlpDefaultGrpcClientRetryBackoffMultiplier() { float value{}; From d703b7225d2df1a5f4305a271518c15e05f9eb16 Mon Sep 17 00:00:00 2001 From: Ansh Rai Date: Tue, 21 Jul 2026 11:21:41 +0530 Subject: [PATCH 06/12] Preserve shared client timeout in signal exporters Signed-off-by: Ansh Rai --- .../exporters/otlp/otlp_environment.h | 4 ++++ exporters/otlp/src/otlp_environment.cc | 18 ++++++++++++++++++ .../otlp/src/otlp_grpc_exporter_options.cc | 6 +++++- .../otlp_grpc_log_record_exporter_options.cc | 6 +++++- .../src/otlp_grpc_metric_exporter_options.cc | 6 +++++- .../otlp/test/otlp_grpc_client_options_test.cc | 15 +++++++++++++++ 6 files changed, 52 insertions(+), 3 deletions(-) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h index ac193a4f75..6ae697f546 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h @@ -122,6 +122,10 @@ std::chrono::system_clock::duration GetOtlpDefaultTracesTimeout(); std::chrono::system_clock::duration GetOtlpDefaultMetricsTimeout(); std::chrono::system_clock::duration GetOtlpDefaultLogsTimeout(); +bool GetOtlpDefaultTracesTimeoutOverride(std::chrono::system_clock::duration &value); +bool GetOtlpDefaultMetricsTimeoutOverride(std::chrono::system_clock::duration &value); +bool GetOtlpDefaultLogsTimeoutOverride(std::chrono::system_clock::duration &value); + // Compatibility with OTELCPP 1.8.2 inline std::chrono::system_clock::duration GetOtlpDefaultTimeout() { diff --git a/exporters/otlp/src/otlp_environment.cc b/exporters/otlp/src/otlp_environment.cc index 7fd92da15c..d535ca0d9e 100644 --- a/exporters/otlp/src/otlp_environment.cc +++ b/exporters/otlp/src/otlp_environment.cc @@ -1012,6 +1012,24 @@ std::chrono::system_clock::duration GetOtlpDefaultLogsTimeout() return value; } +bool GetOtlpDefaultTracesTimeoutOverride(std::chrono::system_clock::duration &value) +{ + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT"; + return sdk_common::GetDurationEnvironmentVariable(kSignalEnv, value); +} + +bool GetOtlpDefaultMetricsTimeoutOverride(std::chrono::system_clock::duration &value) +{ + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT"; + return sdk_common::GetDurationEnvironmentVariable(kSignalEnv, value); +} + +bool GetOtlpDefaultLogsTimeoutOverride(std::chrono::system_clock::duration &value) +{ + constexpr char kSignalEnv[] = "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT"; + return sdk_common::GetDurationEnvironmentVariable(kSignalEnv, value); +} + void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name) { std::string raw_value; diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index c374938149..b03991ceeb 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -51,7 +51,11 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) : OtlpGrpcClientOptions OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &client_options) : OtlpGrpcClientOptions(client_options) { - timeout = GetOtlpDefaultTracesTimeout(); + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultTracesTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } metadata = GetOtlpDefaultTracesHeaders(); #ifdef ENABLE_ASYNC_EXPORT diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index 4978a73994..ef7059bb60 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -60,7 +60,11 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( const OtlpGrpcClientOptions &client_options) : OtlpGrpcClientOptions(client_options) { - timeout = GetOtlpDefaultLogsTimeout(); + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultLogsTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } metadata = GetOtlpDefaultLogsHeaders(); #ifdef ENABLE_ASYNC_EXPORT diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index 03c9c574af..775323e5bf 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -64,7 +64,11 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( : OtlpGrpcClientOptions(client_options), aggregation_temporality(PreferredAggregationTemporality::kCumulative) { - timeout = GetOtlpDefaultMetricsTimeout(); + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultMetricsTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } metadata = GetOtlpDefaultMetricsHeaders(); #ifdef ENABLE_ASYNC_EXPORT diff --git a/exporters/otlp/test/otlp_grpc_client_options_test.cc b/exporters/otlp/test/otlp_grpc_client_options_test.cc index 409ed65650..4ccb185060 100644 --- a/exporters/otlp/test/otlp_grpc_client_options_test.cc +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -119,6 +119,21 @@ TEST(OtlpGrpcClientOptionsTest, SignalWithoutSpecificOverrideFallsBackToSharedCl EXPECT_EQ(metric_options.timeout, std::chrono::seconds(20)); } +TEST(OtlpGrpcClientOptionsTest, ProgrammaticSharedClientTimeoutIsPreservedWithoutEnvVar) +{ + OtlpGrpcClientOptions client_options(static_cast(nullptr)); + client_options.timeout = std::chrono::seconds(30); + + OtlpGrpcExporterOptions trace_options(client_options); + EXPECT_EQ(trace_options.timeout, std::chrono::seconds(30)); + + OtlpGrpcMetricExporterOptions metric_options(client_options); + EXPECT_EQ(metric_options.timeout, std::chrono::seconds(30)); + + OtlpGrpcLogRecordExporterOptions log_options(client_options); + EXPECT_EQ(log_options.timeout, std::chrono::seconds(30)); +} + TEST(OtlpGrpcClientOptionsTest, DerivedVoidPointerConstructorsSkipDefaults) { ScopedEnvVar env("OTEL_EXPORTER_OTLP_ENDPOINT", "https://collector.example.com:4317"); From 7e36ff088f1db3d799749bca0172aa043bc4a5c7 Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Mon, 31 Aug 2026 10:32:18 -0400 Subject: [PATCH 07/12] fix formatting --- exporters/otlp/BUILD | 2 +- exporters/otlp/CMakeLists.txt | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/exporters/otlp/BUILD b/exporters/otlp/BUILD index 614a834903..b5e9dd545e 100644 --- a/exporters/otlp/BUILD +++ b/exporters/otlp/BUILD @@ -770,8 +770,8 @@ cc_test( deps = [ ":otlp_grpc_client", ":otlp_grpc_exporter", - ":otlp_grpc_metric_exporter", ":otlp_grpc_log_record_exporter", + ":otlp_grpc_metric_exporter", "@com_google_googletest//:gtest_main", ], ) diff --git a/exporters/otlp/CMakeLists.txt b/exporters/otlp/CMakeLists.txt index 00855f8c3d..f529549ba8 100644 --- a/exporters/otlp/CMakeLists.txt +++ b/exporters/otlp/CMakeLists.txt @@ -895,8 +895,11 @@ if(OTELCPP_BUILD_TESTING) add_executable(otlp_grpc_client_options_test test/otlp_grpc_client_options_test.cc) target_link_libraries( - otlp_grpc_client_options_test ${GTEST_BOTH_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} ${GMOCK_LIB} opentelemetry_exporter_otlp_grpc + otlp_grpc_client_options_test + ${GTEST_BOTH_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ${GMOCK_LIB} + opentelemetry_exporter_otlp_grpc opentelemetry_exporter_otlp_grpc_log opentelemetry_exporter_otlp_grpc_metrics) gtest_add_tests( From 7c2bc6d8422b7613f06ff7665a3a244f44f39e53 Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Mon, 31 Aug 2026 10:39:33 -0400 Subject: [PATCH 08/12] fix iwyu warnings --- .../opentelemetry/exporters/otlp/otlp_grpc_client_options.h | 2 ++ exporters/otlp/src/otlp_grpc_exporter_options.cc | 1 + exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc | 1 + exporters/otlp/src/otlp_grpc_metric_exporter_options.cc | 2 ++ exporters/otlp/test/otlp_grpc_client_options_test.cc | 1 + 5 files changed, 7 insertions(+) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h index ea6ef23ffc..a5c0267e58 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h @@ -7,6 +7,8 @@ #include "opentelemetry/version.h" #include +#include +#include #include #include diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index b03991ceeb..3278683bfc 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -5,6 +5,7 @@ #include #include "opentelemetry/exporters/otlp/otlp_environment.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" #include "opentelemetry/version.h" diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index ef7059bb60..eac57920cc 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -5,6 +5,7 @@ #include #include "opentelemetry/exporters/otlp/otlp_environment.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h" #include "opentelemetry/version.h" diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index ee83e02b43..d30381aef9 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -5,7 +5,9 @@ #include #include "opentelemetry/exporters/otlp/otlp_environment.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h" +#include "opentelemetry/exporters/otlp/otlp_preferred_temporality.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE diff --git a/exporters/otlp/test/otlp_grpc_client_options_test.cc b/exporters/otlp/test/otlp_grpc_client_options_test.cc index 4ccb185060..b72c8dfcb0 100644 --- a/exporters/otlp/test/otlp_grpc_client_options_test.cc +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -10,6 +10,7 @@ #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h" +#include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE namespace exporter From 8b457124ed4e0a1bc5a1faf2a40170c7309d162b Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Mon, 31 Aug 2026 10:54:55 -0400 Subject: [PATCH 09/12] fix clang-tidy warnings --- .../exporters/otlp/otlp_grpc_client_options.h | 6 +++--- exporters/otlp/src/otlp_grpc_client_options.cc | 14 +------------- exporters/otlp/src/otlp_grpc_exporter_options.cc | 10 +--------- .../src/otlp_grpc_log_record_exporter_options.cc | 9 +-------- .../otlp/src/otlp_grpc_metric_exporter_options.cc | 15 +++------------ .../otlp/test/otlp_grpc_client_options_test.cc | 5 +++++ 6 files changed, 14 insertions(+), 45 deletions(-) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h index a5c0267e58..c35e474bef 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h @@ -43,7 +43,7 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcClientOptions std::string endpoint; /** Use SSL. */ - bool use_ssl_credentials{}; + bool use_ssl_credentials{true}; /** CA CERT, path to a file. */ std::string ssl_credentials_cacert_path; @@ -78,14 +78,14 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcClientOptions std::string user_agent; /** max number of threads that can be allocated from this */ - std::size_t max_threads{}; + std::size_t max_threads{0}; /** Compression type. */ std::string compression; #ifdef ENABLE_ASYNC_EXPORT // Concurrent requests - std::size_t max_concurrent_requests{}; + std::size_t max_concurrent_requests{64}; #endif /** The maximum number of call attempts, including the original attempt. */ diff --git a/exporters/otlp/src/otlp_grpc_client_options.cc b/exporters/otlp/src/otlp_grpc_client_options.cc index 46660d542b..77829fa97a 100644 --- a/exporters/otlp/src/otlp_grpc_client_options.cc +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -19,11 +19,7 @@ OtlpGrpcClientOptions::OtlpGrpcClientOptions() timeout(GetOtlpDefaultGrpcClientTimeout()), metadata(GetOtlpDefaultGrpcClientHeaders()), user_agent(GetOtlpDefaultUserAgent()), - max_threads(0), compression(GetOtlpDefaultGrpcClientCompression()), -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests(64), -#endif retry_policy_max_attempts(GetOtlpDefaultGrpcClientRetryMaxAttempts()), retry_policy_initial_backoff(GetOtlpDefaultGrpcClientRetryInitialBackoff()), retry_policy_max_backoff(GetOtlpDefaultGrpcClientRetryMaxBackoff()), @@ -37,15 +33,7 @@ OtlpGrpcClientOptions::OtlpGrpcClientOptions() #endif } -OtlpGrpcClientOptions::OtlpGrpcClientOptions(void *) -{ - use_ssl_credentials = true; - max_threads = 0; - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif -} +OtlpGrpcClientOptions::OtlpGrpcClientOptions(void *) {} OtlpGrpcClientOptions::~OtlpGrpcClientOptions() {} diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 3278683bfc..075052c88a 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -39,15 +39,7 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() : OtlpGrpcClientOptions() retry_policy_backoff_multiplier = GetOtlpDefaultTracesRetryBackoffMultiplier(); } -OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) : OtlpGrpcClientOptions(nullptr) -{ - use_ssl_credentials = true; - max_threads = 0; - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif -} +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) : OtlpGrpcClientOptions(nullptr) {} OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &client_options) : OtlpGrpcClientOptions(client_options) diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index eac57920cc..a53c0ea1a5 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -48,14 +48,7 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions() OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions(void *) : OtlpGrpcClientOptions(nullptr) -{ - use_ssl_credentials = true; - max_threads = 0; - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif -} +{} OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( const OtlpGrpcClientOptions &client_options) diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index d30381aef9..fb62d20726 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -48,21 +48,12 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions() } OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions(void *) - : OtlpGrpcClientOptions(nullptr), - aggregation_temporality(PreferredAggregationTemporality::kCumulative) -{ - use_ssl_credentials = true; - max_threads = 0; - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif -} + : OtlpGrpcClientOptions(nullptr) +{} OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( const OtlpGrpcClientOptions &client_options) - : OtlpGrpcClientOptions(client_options), - aggregation_temporality(PreferredAggregationTemporality::kCumulative) + : OtlpGrpcClientOptions(client_options) { std::chrono::system_clock::duration signal_timeout; if (GetOtlpDefaultMetricsTimeoutOverride(signal_timeout)) diff --git a/exporters/otlp/test/otlp_grpc_client_options_test.cc b/exporters/otlp/test/otlp_grpc_client_options_test.cc index b72c8dfcb0..550bfe3630 100644 --- a/exporters/otlp/test/otlp_grpc_client_options_test.cc +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -32,6 +32,11 @@ class ScopedEnvVar #endif } + ScopedEnvVar(const ScopedEnvVar &) = delete; + ScopedEnvVar &operator=(const ScopedEnvVar &) = delete; + ScopedEnvVar(ScopedEnvVar &&) = delete; + ScopedEnvVar &operator=(ScopedEnvVar &&) = delete; + ~ScopedEnvVar() { #ifdef _MSC_VER From 23935d4b3d030841f5801fe856eb19553ea9db54 Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Mon, 31 Aug 2026 11:05:33 -0400 Subject: [PATCH 10/12] cleanup --- .../otlp/src/otlp_grpc_exporter_options.cc | 4 ---- .../otlp_grpc_log_record_exporter_options.cc | 19 ++++--------------- .../src/otlp_grpc_metric_exporter_options.cc | 19 ++++--------------- 3 files changed, 8 insertions(+), 34 deletions(-) diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 075052c88a..a49c1b72ad 100644 --- a/exporters/otlp/src/otlp_grpc_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_exporter_options.cc @@ -50,10 +50,6 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &cl timeout = signal_timeout; } metadata = GetOtlpDefaultTracesHeaders(); - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = client_options.max_concurrent_requests; -#endif } OtlpGrpcExporterOptions::~OtlpGrpcExporterOptions() {} diff --git a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc index a53c0ea1a5..76cad75efa 100644 --- a/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_log_record_exporter_options.cc @@ -29,17 +29,10 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions() ssl_client_cert_string = GetOtlpDefaultLogsSslClientCertificateString(); #endif - timeout = GetOtlpDefaultLogsTimeout(); - metadata = GetOtlpDefaultLogsHeaders(); - user_agent = GetOtlpDefaultUserAgent(); - - max_threads = 0; - - compression = GetOtlpDefaultLogsCompression(); -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif - + timeout = GetOtlpDefaultLogsTimeout(); + metadata = GetOtlpDefaultLogsHeaders(); + user_agent = GetOtlpDefaultUserAgent(); + compression = GetOtlpDefaultLogsCompression(); retry_policy_max_attempts = GetOtlpDefaultLogsRetryMaxAttempts(); retry_policy_initial_backoff = GetOtlpDefaultLogsRetryInitialBackoff(); retry_policy_max_backoff = GetOtlpDefaultLogsRetryMaxBackoff(); @@ -60,10 +53,6 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( timeout = signal_timeout; } metadata = GetOtlpDefaultLogsHeaders(); - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = client_options.max_concurrent_requests; -#endif } OtlpGrpcLogRecordExporterOptions::~OtlpGrpcLogRecordExporterOptions() {} diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index fb62d20726..f479773104 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -30,17 +30,10 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions() ssl_client_cert_string = GetOtlpDefaultMetricsSslClientCertificateString(); #endif - timeout = GetOtlpDefaultMetricsTimeout(); - metadata = GetOtlpDefaultMetricsHeaders(); - user_agent = GetOtlpDefaultUserAgent(); - - max_threads = 0; - - compression = GetOtlpDefaultMetricsCompression(); -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif - + timeout = GetOtlpDefaultMetricsTimeout(); + metadata = GetOtlpDefaultMetricsHeaders(); + user_agent = GetOtlpDefaultUserAgent(); + compression = GetOtlpDefaultMetricsCompression(); retry_policy_max_attempts = GetOtlpDefaultMetricsRetryMaxAttempts(); retry_policy_initial_backoff = GetOtlpDefaultMetricsRetryInitialBackoff(); retry_policy_max_backoff = GetOtlpDefaultMetricsRetryMaxBackoff(); @@ -61,10 +54,6 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( timeout = signal_timeout; } metadata = GetOtlpDefaultMetricsHeaders(); - -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = client_options.max_concurrent_requests; -#endif } OtlpGrpcMetricExporterOptions::~OtlpGrpcMetricExporterOptions() {} From fa16125cc5a2b10e6a7748721ecc2f2083917765 Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Mon, 31 Aug 2026 11:09:48 -0400 Subject: [PATCH 11/12] fix iwyu warning --- exporters/otlp/src/otlp_grpc_metric_exporter_options.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc index f479773104..8a3fb2a200 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc @@ -7,7 +7,6 @@ #include "opentelemetry/exporters/otlp/otlp_environment.h" #include "opentelemetry/exporters/otlp/otlp_grpc_client_options.h" #include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h" -#include "opentelemetry/exporters/otlp/otlp_preferred_temporality.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE From 6dd46c09dc0f7fdd7ce4611b6bfaaa51cb1cb562 Mon Sep 17 00:00:00 2001 From: Douglas Barker Date: Tue, 1 Sep 2026 10:55:25 -0400 Subject: [PATCH 12/12] fix iwyu warning --- .../exporters/otlp/otlp_grpc_client_options.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h index c35e474bef..500bd87afe 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_client_options.h @@ -9,12 +9,17 @@ #include #include #include -#include #include +#ifdef ENABLE_OTLP_GRPC_CREDENTIAL_PREVIEW +# include +#endif + namespace grpc { +#ifdef ENABLE_OTLP_GRPC_CREDENTIAL_PREVIEW class ChannelCredentials; +#endif class ChannelArguments; } // namespace grpc