diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c57ff645..5522c1215 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,13 @@ Increment the: ## [Unreleased] +* [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) diff --git a/exporters/otlp/BUILD b/exporters/otlp/BUILD index f756afa69..2ff1fadac 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 eef251a1d..dd5df1a4d 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) @@ -932,6 +933,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 f6ea55d32..03e467d51 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 @@ -168,6 +169,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); + +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 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 f524b27b9..0d8bce0ca 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,10 +22,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; 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 2bb4ab654..3e03eae11 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 8e6f53644..67b2917c0 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 ab6c8795f..628ece589 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 e8aae4589..4e977b24a 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 new file mode 100644 index 000000000..46660d542 --- /dev/null +++ b/exporters/otlp/src/otlp_grpc_client_options.cc @@ -0,0 +1,54 @@ +// 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()), + 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()) +{ +#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 *) +{ + 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 diff --git a/exporters/otlp/src/otlp_grpc_exporter_options.cc b/exporters/otlp/src/otlp_grpc_exporter_options.cc index 482a5193e..c37493814 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(); @@ -45,7 +38,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 +48,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 = client_options.max_concurrent_requests; +#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 55c108c03..4978a7399 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 = client_options.max_concurrent_requests; +#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 540357ff9..03c9c574a 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 = client_options.max_concurrent_requests; +#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 000000000..409ed6565 --- /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