diff --git a/CHANGELOG.md b/CHANGELOG.md index 970ee8b1c9..bfa3966fdd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -218,6 +218,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 e8a64887c3..b5e9dd545e 100644 --- a/exporters/otlp/BUILD +++ b/exporters/otlp/BUILD @@ -91,6 +91,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 = [ @@ -114,6 +115,7 @@ cc_library( deps = [ ":otlp_common", "//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", @@ -757,6 +759,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_log_record_exporter", + ":otlp_grpc_metric_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 b63ab23eca..f529549ba8 100644 --- a/exporters/otlp/CMakeLists.txt +++ b/exporters/otlp/CMakeLists.txt @@ -116,7 +116,8 @@ if(OTELCPP_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) @@ -891,6 +892,21 @@ if(OTELCPP_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 c275f4eaa4..c969b5ac38 100644 --- a/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h +++ b/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include @@ -121,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() { @@ -168,6 +173,30 @@ 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. + */ + +void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name); + +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 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 43d4435f54..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 @@ -7,12 +7,19 @@ #include "opentelemetry/version.h" #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 @@ -22,10 +29,16 @@ namespace exporter namespace otlp { -struct OtlpGrpcClientOptions +struct OPENTELEMETRY_EXPORT 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; @@ -35,7 +48,7 @@ struct 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; @@ -70,14 +83,14 @@ struct 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/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 0ead376fae..f07ba569c1 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_environment.cc b/exporters/otlp/src/otlp_environment.cc index e8aae45898..d535ca0d9e 100644 --- a/exporters/otlp/src/otlp_environment.cc +++ b/exporters/otlp/src/otlp_environment.cc @@ -30,6 +30,30 @@ namespace exporter namespace otlp { +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) { bool exists{}; @@ -113,14 +137,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 +155,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 +173,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 +191,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 +203,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 +215,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 +227,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 +239,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 +251,7 @@ std::string GetOtlpDefaultHttpLogsEndpoint() return value; } - exists = sdk_common::GetStringEnvironmentVariable(kGenericEnv, value); + exists = sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value); if (exists) { value += "/v1/logs"; @@ -321,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; } @@ -331,16 +349,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 +374,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; @@ -379,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; } @@ -389,16 +405,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 +430,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; @@ -437,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; } @@ -447,13 +461,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 +477,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 +493,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 +509,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 +525,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 +541,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 +557,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 +573,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 +589,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 +605,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 +621,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 +637,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 +653,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 +669,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 +685,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 +701,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 +717,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 +733,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 +749,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 +771,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 +787,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 +803,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 +819,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 +835,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 +851,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 +867,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 +883,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 +899,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 +915,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 +931,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 +947,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 +963,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 +980,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 +997,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 +1012,25 @@ std::chrono::system_clock::duration GetOtlpDefaultLogsTimeout() return value; } -static void DumpOtlpHeaders(OtlpHeaders &output, const char *env_var_name) +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; bool exists{}; @@ -1083,37 +1081,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 +1118,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 +1134,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 +1150,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 +1163,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 +1176,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 +1189,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 +1202,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 +1215,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 +1228,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 +1241,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 +1254,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 +1267,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 +1280,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 +1293,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; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientEndpoint() +{ + constexpr char kDefault[] = "http://localhost:4317"; + + std::string value; + + if (sdk_common::GetStringEnvironmentVariable(kEnvOtlpEndpoint, value)) + { + return value; + } + + return kDefault; +} + +OPENTELEMETRY_EXPORT bool GetOtlpDefaultGrpcClientIsInsecure() +{ + std::string endpoint = GetOtlpDefaultGrpcClientEndpoint(); + + if (opentelemetry::nostd::string_view(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; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificatePath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificate, value); + return value; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslCertificateString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpCertificateString, value); + return value; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyPath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKey, value); + return value; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientKeyString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientKeyString, value); + return value; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificatePath() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificate, value); + return value; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientSslClientCertificateString() +{ + std::string value; + sdk_common::GetStringEnvironmentVariable(kEnvOtlpClientCertificateString, value); + return value; +} + +OPENTELEMETRY_EXPORT 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}); +} + +OPENTELEMETRY_EXPORT OtlpHeaders GetOtlpDefaultGrpcClientHeaders() +{ + OtlpHeaders result; + DumpOtlpHeaders(result, kEnvOtlpHeaders); + return result; +} + +OPENTELEMETRY_EXPORT std::string GetOtlpDefaultGrpcClientCompression() +{ + std::string value; + + if (sdk_common::GetStringEnvironmentVariable(kEnvOtlpCompression, value)) + { + return value; + } + + return std::string{"none"}; +} + +OPENTELEMETRY_EXPORT std::uint32_t GetOtlpDefaultGrpcClientRetryMaxAttempts() +{ + std::uint32_t value{}; + + if (sdk_common::GetUintEnvironmentVariable(kEnvOtlpRetryMaxAttempts, value)) + { + return value; + } + + return 5U; +} + +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryInitialBackoff() +{ + float value{}; + + if (sdk_common::GetFloatEnvironmentVariable(kEnvOtlpRetryInitialBackoff, value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{1.0f}; +} + +OPENTELEMETRY_EXPORT std::chrono::duration GetOtlpDefaultGrpcClientRetryMaxBackoff() +{ + float value{}; + + if (sdk_common::GetFloatEnvironmentVariable(kEnvOtlpRetryMaxBackoff, value)) + { + return std::chrono::duration{value}; + } + + return std::chrono::duration{5.0f}; +} + +OPENTELEMETRY_EXPORT 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 new file mode 100644 index 0000000000..77829fa97a --- /dev/null +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -0,0 +1,42 @@ +// 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()), + timeout(GetOtlpDefaultGrpcClientTimeout()), + metadata(GetOtlpDefaultGrpcClientHeaders()), + user_agent(GetOtlpDefaultUserAgent()), + compression(GetOtlpDefaultGrpcClientCompression()), + retry_policy_max_attempts(GetOtlpDefaultGrpcClientRetryMaxAttempts()), + retry_policy_initial_backoff(GetOtlpDefaultGrpcClientRetryInitialBackoff()), + retry_policy_max_backoff(GetOtlpDefaultGrpcClientRetryMaxBackoff()), + retry_policy_backoff_multiplier(GetOtlpDefaultGrpcClientRetryBackoffMultiplier()) +{ +#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 +} + +OtlpGrpcClientOptions::OtlpGrpcClientOptions(void *) {} + +OtlpGrpcClientOptions::~OtlpGrpcClientOptions() {} + +} // namespace otlp +} // namespace exporter +OPENTELEMETRY_END_NAMESPACE diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 482a5193ec..a49c1b72ad 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" @@ -14,7 +15,7 @@ namespace exporter namespace otlp { -OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() : OtlpGrpcClientOptions() { endpoint = GetOtlpDefaultGrpcTracesEndpoint(); use_ssl_credentials = !GetOtlpDefaultGrpcTracesIsInsecure(); /* negation intended. */ @@ -28,16 +29,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(); @@ -45,14 +39,17 @@ OtlpGrpcExporterOptions::OtlpGrpcExporterOptions() retry_policy_backoff_multiplier = GetOtlpDefaultTracesRetryBackoffMultiplier(); } -OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) -{ - use_ssl_credentials = true; - max_threads = 0; +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(void *) : OtlpGrpcClientOptions(nullptr) {} -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif +OtlpGrpcExporterOptions::OtlpGrpcExporterOptions(const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options) +{ + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultTracesTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } + metadata = GetOtlpDefaultTracesHeaders(); } 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 55c108c03d..76cad75efa 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" @@ -28,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(); @@ -46,13 +40,19 @@ OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions() } OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions(void *) -{ - use_ssl_credentials = true; - max_threads = 0; + : OtlpGrpcClientOptions(nullptr) +{} -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif +OtlpGrpcLogRecordExporterOptions::OtlpGrpcLogRecordExporterOptions( + const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options) +{ + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultLogsTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } + metadata = GetOtlpDefaultLogsHeaders(); } 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 1c00faefcd..8a3fb2a200 100644 --- a/exporters/otlp/src/otlp_grpc_metric_exporter_options.cc +++ b/exporters/otlp/src/otlp_grpc_metric_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_metric_exporter_options.h" #include "opentelemetry/version.h" @@ -28,17 +29,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(); @@ -46,13 +40,19 @@ OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions() } OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions(void *) -{ - use_ssl_credentials = true; - max_threads = 0; + : OtlpGrpcClientOptions(nullptr) +{} -#ifdef ENABLE_ASYNC_EXPORT - max_concurrent_requests = 64; -#endif +OtlpGrpcMetricExporterOptions::OtlpGrpcMetricExporterOptions( + const OtlpGrpcClientOptions &client_options) + : OtlpGrpcClientOptions(client_options) +{ + std::chrono::system_clock::duration signal_timeout; + if (GetOtlpDefaultMetricsTimeoutOverride(signal_timeout)) + { + timeout = signal_timeout; + } + metadata = GetOtlpDefaultMetricsHeaders(); } OtlpGrpcMetricExporterOptions::~OtlpGrpcMetricExporterOptions() {} 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..550bfe3630 --- /dev/null +++ b/exporters/otlp/test/otlp_grpc_client_options_test.cc @@ -0,0 +1,159 @@ +// 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" +#include "opentelemetry/version.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(const ScopedEnvVar &) = delete; + ScopedEnvVar &operator=(const ScopedEnvVar &) = delete; + ScopedEnvVar(ScopedEnvVar &&) = delete; + ScopedEnvVar &operator=(ScopedEnvVar &&) = delete; + + ~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, 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"); + + 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