minimized the grpc/absl hang case, exposed --config=hangbug to demonstrate it in x/hang

Author: malkia

dll_deps.bzl

@@ -16,7 +16,7 @@ def _filter_libs(deps):
 def dll_deps(deps):
     """ When building with --//:with_dll=true replaces the references to the api/sdk/exporters/ext static libraries with the single //:dll shared library """
     return select({
-        "//:with_dll_enabled": ["//:dll"] + _filter_libs(deps),
+        "@otel_sdk//:with_dll_enabled": ["@otel_sdk//:dll"] + _filter_libs(deps),
         "//conditions:default": deps,
     })
 

x/.bazelrc

@@ -14,4 +14,9 @@ test:devenv --run_under='"c:/windows/system32/cmd.exe" /c start /wait devenv /de
 #common:slrun --run_under='sudo -E --inline q:/superluminal/SuperluminalCmd.exe run windows --symbol-location q:/symbols --resolve --symbol-cache-dir q:/symcache '
 #common:test1 --run_under='"c:/windows/system32/cmd.exe" /k set 1>d:\\1.txt 2>d:\\2.txt && echo a '
 
-common --incompatible_disable_target_provider_fields=false
+common --incompatible_disable_target_provider_fields=false
+
+# This disables the gprc hanging fix
+build:hangbug --copt="-UGRPC_NO_ABSL_SYNC"
+build:hangbug --host_copt="-UGRPC_NO_ABSL_SYNC"
+build:hangbug --platform_suffix=hangbug

x/hang/BUILD.bazel

@@ -1,7 +1,12 @@
+load("@otel_sdk//:dll_deps.bzl", "dll_deps")
+
 cc_test(
    name = "hang",
-   srcs = ["hang.cpp", "otel_sdk.cpp", "otel_sdk.h"],
-   deps = ["@otel_sdk//:dll"],
+   srcs = ["hang.cpp"],
+   deps = dll_deps([
+      "@otel_sdk//exporters/otlp:otlp_grpc_log_record_exporter",
+      "@otel_sdk//exporters/otlp:otlp_grpc_metric_exporter",
+   ]),
    size = "enormous",
    timeout = "eternal",
 )

x/hang/hang.cpp

@@ -1,33 +1,80 @@
-#include "otel_sdk.h"
-
-#include <opentelemetry/version.h>
 #include <opentelemetry/logs/provider.h>
 #include <opentelemetry/metrics/provider.h>
 
-int main(int argc, const char* argv[])
+#include <opentelemetry/sdk/logs/logger_provider_factory.h>
+#include <opentelemetry/sdk/metrics/meter_provider_factory.h>
+
+#include <opentelemetry/sdk/logs/batch_log_record_processor_factory.h>
+#include <opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_factory.h>
+
+#include <opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_factory.h>
+#include <opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_factory.h>
+
+namespace otel_sdk
 {
-  using namespace opentelemetry;
+using namespace opentelemetry;
+
+struct instance
+{
+	instance();
+	~instance();
+};
+
+static void init_metrics()
+{
+	exporter::otlp::OtlpGrpcMetricExporterOptions exporterOptions;
+	exporterOptions.endpoint = "localhost:65534";
+	exporterOptions.max_concurrent_requests = 0;
+	auto exporter{ exporter::otlp::OtlpGrpcMetricExporterFactory::Create( exporterOptions ) };
+	sdk::metrics::PeriodicExportingMetricReaderOptions readerOptions;
+	readerOptions.export_interval_millis = std::chrono::milliseconds(500);
+	readerOptions.export_timeout_millis  = std::chrono::milliseconds(250);
+	auto reader{ sdk::metrics::PeriodicExportingMetricReaderFactory::Create( std::move( exporter ), readerOptions ) };
+	auto meterProvider{ sdk::metrics::MeterProviderFactory::Create() };
+	meterProvider->AddMetricReader( std::move( reader ) );
+	metrics::Provider::SetMeterProvider( std::move( meterProvider ) );
+}
 
-  otel_sdk::instance instance;
-  std::unique_ptr<metrics::Counter<double>> counter;
-
-  auto provider = metrics::Provider::GetMeterProvider();
-  auto meter{ provider->GetMeter("malkia_test_meter", "1.2.0") };
-  std::vector<std::unique_ptr<metrics::Counter<double>>> counters;
-  counters.reserve(10);
-  for(int i=0; i<10; i++)
-  {
-    char buf[100];
-    sprintf(buf,"counter_%d", i);
-    counters.push_back( std::move( meter->CreateDoubleCounter(buf)));
-  }
-  for(int i=0; i<10; i++)
-  {
-      counters[i]->Add(1);
-  }
-  std::this_thread::sleep_for(std::chrono::seconds(2));
-
-  quick_exit(0);
 
+static void init_logs()
+{
+	exporter::otlp::OtlpGrpcLogRecordExporterOptions exporterOptions;
+	exporterOptions.endpoint = "localhost:65535";
+	exporterOptions.max_concurrent_requests = 0;
+	auto exporter = exporter::otlp::OtlpGrpcLogRecordExporterFactory::Create( exporterOptions );
+	sdk::logs::BatchLogRecordProcessorOptions processorOptions;
+	processorOptions.max_export_batch_size = 8192;
+	processorOptions.max_queue_size = 65536;
+	processorOptions.schedule_delay_millis = std::chrono::milliseconds{ 10000 };
+	auto processor = sdk::logs::BatchLogRecordProcessorFactory::Create( std::move( exporter ), processorOptions );
+	std::vector<std::unique_ptr<sdk::logs::LogRecordProcessor>> logRecordProcessors;
+	logRecordProcessors.emplace_back( std::move( processor ) );
+	auto loggerProvider( sdk::logs::LoggerProviderFactory::Create( std::move( logRecordProcessors ) ) );
+	logs::Provider::SetLoggerProvider( std::move( loggerProvider ) );
+}
+
+instance::instance()
+{
+	init_metrics();
+	init_logs();
+	_Exit(0);
+}
+
+instance::~instance()
+{
+	auto meterProvider{ std::dynamic_pointer_cast<sdk::metrics::MeterProvider>( metrics::Provider::GetMeterProvider() ) };
+	auto logProvider{ std::dynamic_pointer_cast<sdk::logs::LoggerProvider>( logs::Provider::GetLoggerProvider() ) };
+	if( meterProvider )
+		meterProvider->Shutdown(std::chrono::seconds(1));
+	if( logProvider )
+		logProvider->Shutdown(std::chrono::seconds(1));
+	metrics::Provider::SetMeterProvider( {} );
+	logs::Provider::SetLoggerProvider( {} );
+}
+} // namespace otel_sdk
+
+int main(int argc, const char* argv[])
+{
+  otel_sdk::instance instance;
   return 0;
 }