Update Stable Config native extension to support libdatadog 21 and add support for debug logs

vpellan · ericfirth · commit c498ef2f58c6 · 2025-10-01T14:22:36.000-04:00
diff --git a/ext/libdatadog_api/library_config.c b/ext/libdatadog_api/library_config.c
@@ -11,7 +11,7 @@ static VALUE _native_configurator_get(VALUE self);
 static VALUE _native_configurator_with_local_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path);
 static VALUE _native_configurator_with_fleet_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path);
 
-static VALUE config_vec_class = Qnil;
+static VALUE config_logged_result_class = Qnil;
 
 // ddog_Configurator memory management
 static void configurator_free(void *configurator_ptr) {
@@ -29,29 +29,29 @@ static const rb_data_type_t configurator_typed_data = {
   .flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-// ddog_Vec_LibraryConfig memory management
-static void config_vec_free(void *config_vec_ptr) {
-  ddog_Vec_LibraryConfig *config_vec = (ddog_Vec_LibraryConfig *)config_vec_ptr;
+// ddog_LibraryConfigLoggedResult memory management
+static void config_logged_result_free(void *config_logged_result_ptr) {
+  ddog_LibraryConfigLoggedResult *config_logged_result = (ddog_LibraryConfigLoggedResult *)config_logged_result_ptr;
 
-  ddog_library_config_drop(*config_vec);
-  ruby_xfree(config_vec_ptr);
+  ddog_library_config_drop(*config_logged_result);
+  ruby_xfree(config_logged_result_ptr);
 }
 
-static const rb_data_type_t config_vec_typed_data = {
-  .wrap_struct_name = "Datadog::Core::Configuration::StableConfigVec",
+static const rb_data_type_t config_logged_result_typed_data = {
+  .wrap_struct_name = "Datadog::Core::Configuration::StableConfigLoggedResult",
   .function = {
-    .dfree = config_vec_free,
+    .dfree = config_logged_result_free,
     .dsize = NULL,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
 void library_config_init(VALUE core_module) {
-  rb_global_variable(&config_vec_class);
+  rb_global_variable(&config_logged_result_class);
   VALUE configuration_module = rb_define_module_under(core_module, "Configuration");
   VALUE stable_config_module = rb_define_module_under(configuration_module, "StableConfig");
   VALUE configurator_class = rb_define_class_under(stable_config_module, "Configurator", rb_cObject);
-  config_vec_class = rb_define_class_under(configuration_module, "StableConfigVec", rb_cObject);
+  config_logged_result_class = rb_define_class_under(configuration_module, "StableConfigLoggedResult", rb_cObject);
 
   rb_define_alloc_func(configurator_class, _native_configurator_new);
   rb_define_method(configurator_class, "get", _native_configurator_get, 0);
@@ -61,11 +61,12 @@ void library_config_init(VALUE core_module) {
   rb_define_singleton_method(testing_module, "with_local_path", _native_configurator_with_local_path, 2);
   rb_define_singleton_method(testing_module, "with_fleet_path", _native_configurator_with_fleet_path, 2);
 
-  rb_undef_alloc_func(config_vec_class); // It cannot be created from Ruby code and only serves as an intermediate object for the Ruby GC
+  rb_undef_alloc_func(config_logged_result_class); // It cannot be created from Ruby code and only serves as an intermediate object for the Ruby GC
 }
 
 static VALUE _native_configurator_new(VALUE klass) {
-  ddog_Configurator *configurator = ddog_library_configurator_new(false, DDOG_CHARSLICE_C("ruby"));
+  // We always collect debug logs, so if DD_TRACE_DEBUG is set by stable config, we'll be able to log them.
+  ddog_Configurator *configurator = ddog_library_configurator_new(true, DDOG_CHARSLICE_C("ruby"));
 
   ddog_library_configurator_with_detect_process_info(configurator);
 
@@ -98,27 +99,33 @@ static VALUE _native_configurator_get(VALUE self) {
   ddog_Configurator *configurator;
   TypedData_Get_Struct(self, ddog_Configurator, &configurator_typed_data, configurator);
 
-  ddog_Result_VecLibraryConfig configurator_result = ddog_library_configurator_get(configurator);
+  // Wrapping config_logged_result into a Ruby object enables the Ruby GC to manage its memory
+  // We need to allocate memory for config_logged_result because once it is out of scope, it will be freed (at the end of this function)
+  // So we cannot reference it with &config_logged_result
+  // We are doing this in case one of the ruby API raises an exception before the end of this function,
+  // so the allocated memory will still be freed
+  ddog_LibraryConfigLoggedResult *configurator_logged_result = (ddog_LibraryConfigLoggedResult *)ruby_xmalloc(sizeof(ddog_LibraryConfigLoggedResult));
+  *configurator_logged_result = ddog_library_configurator_get(configurator);
+  VALUE config_logged_result_rb = TypedData_Wrap_Struct(config_logged_result_class, &config_logged_result_typed_data, configurator_logged_result);
 
-  if (configurator_result.tag == DDOG_RESULT_VEC_LIBRARY_CONFIG_ERR_VEC_LIBRARY_CONFIG) {
-    ddog_Error err = configurator_result.err;
+  if (configurator_logged_result->tag == DDOG_LIBRARY_CONFIG_LOGGED_RESULT_ERR) {
+    ddog_Error err = configurator_logged_result->err;
     VALUE message = get_error_details_and_drop(&err);
     if (is_config_loaded()) {
       log_warning(message);
     } else {
       log_warning_without_config(message);
     }
+    RB_GC_GUARD(config_logged_result_rb);
     return rb_hash_new();
   }
 
-  // Wrapping config_vec into a Ruby object enables the Ruby GC to manage its memory
-  // We need to allocate memory for config_vec because once it is out of scope, it will be freed (at the end of this function)
-  // So we cannot reference it with &config_vec
-  // We are doing this in case one of the ruby API raises an exception before the end of this function,
-  // so the allocated memory will still be freed
-  ddog_Vec_LibraryConfig *config_vec = ruby_xmalloc(sizeof(ddog_Vec_LibraryConfig));
-  *config_vec = configurator_result.ok;
-  VALUE config_vec_rb = TypedData_Wrap_Struct(config_vec_class, &config_vec_typed_data, config_vec);
+  VALUE logs = Qnil;
+  if (configurator_logged_result->ok.logs.length > 0) {
+    logs = rb_utf8_str_new_cstr(configurator_logged_result->ok.logs.ptr);
+  }
+
+  ddog_Vec_LibraryConfig config_vec = configurator_logged_result->ok.value;
 
   VALUE local_config_hash = rb_hash_new();
   VALUE fleet_config_hash = rb_hash_new();
@@ -127,8 +134,8 @@ static VALUE _native_configurator_get(VALUE self) {
   bool fleet_config_id_set = false;
   VALUE local_hash = rb_hash_new();
   VALUE fleet_hash = rb_hash_new();
-  for (uintptr_t i = 0; i < config_vec->len; i++) {
-    ddog_LibraryConfig config = config_vec->ptr[i];
+  for (uintptr_t i = 0; i < config_vec.len; i++) {
+    ddog_LibraryConfig config = config_vec.ptr[i];
     VALUE selected_hash;
     if (config.source == DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG) {
       selected_hash = local_config_hash;
@@ -156,9 +163,10 @@ static VALUE _native_configurator_get(VALUE self) {
   rb_hash_aset(fleet_hash, ID2SYM(rb_intern("config")), fleet_config_hash);
 
   VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("logs")), logs);
   rb_hash_aset(result, ID2SYM(rb_intern("local")), local_hash);
   rb_hash_aset(result, ID2SYM(rb_intern("fleet")), fleet_hash);
 
-  RB_GC_GUARD(config_vec_rb);
+  RB_GC_GUARD(config_logged_result_rb);
   return result;
 }
diff --git a/lib/datadog/core/configuration.rb b/lib/datadog/core/configuration.rb
@@ -172,8 +172,10 @@ def logger
         end
       end
 
-      def config_init_logger
-        configuration? ? logger : logger_without_configuration
+      # During stable config initialization, we also have to check for DD_TRACE_DEBUG in local and fleet config.
+      # We pass the debug source value
+      def config_init_logger(debug_source_value = DATADOG_ENV[Ext::Diagnostics::ENV_DEBUG_ENABLED])
+        configuration? ? logger : logger_without_configuration(debug_source_value)
       end
 
       # Gracefully shuts down all components.
@@ -290,17 +292,17 @@ def logger_without_components
         end
       end
 
-      def logger_without_configuration
+      def logger_without_configuration(debug_source_value)
         # There's rare cases where we need to use logger during configuration initialization,
         # such as reading stable config. In this case we cannot access configuration.
 
         @temp_config_logger ||= begin
-          debug_env_value = DATADOG_ENV[Ext::Diagnostics::ENV_DEBUG_ENABLED]&.strip&.downcase
-          debug_value = debug_env_value == 'true' || debug_env_value == '1'
+          debug_value = debug_source_value&.strip&.downcase
+          debug = debug_value == 'true' || debug_value == '1'
 
           logger = Core::Logger.new($stdout)
           # We cannot access config and the default level is INFO, so we need to set the level manually
-          logger.level = debug_value ? ::Logger::DEBUG : ::Logger::INFO
+          logger.level = debug ? ::Logger::DEBUG : ::Logger::INFO
           logger
         end
       end
diff --git a/lib/datadog/core/configuration/stable_config.rb b/lib/datadog/core/configuration/stable_config.rb
@@ -10,7 +10,18 @@ def self.extract_configuration
             Datadog.config_init_logger.debug("Cannot enable stable config: #{libdatadog_api_failure}")
             return {}
           end
-          Configurator.new.get
+          config = Configurator.new.get
+          # Take into account stable config values for DD_TRACE_DEBUG
+          if config[:logs]
+            # Priority : Fleet > Environment > Local
+            debug_source_value =
+              config.dig(:fleet, :config, Ext::Diagnostics::ENV_DEBUG_ENABLED) ||
+              DATADOG_ENV[Ext::Diagnostics::ENV_DEBUG_ENABLED] ||
+              config.dig(:local, :config, Ext::Diagnostics::ENV_DEBUG_ENABLED) ||
+              'false'
+            Datadog.config_init_logger(debug_source_value).debug(config[:logs])
+          end
+          config
         end
 
         def self.configuration
diff --git a/sig/datadog/core/configuration.rbs b/sig/datadog/core/configuration.rbs
@@ -9,7 +9,7 @@ module Datadog
 
       def configuration: () -> untyped # The DSL methods have to be explicitly declared for this to be typed
 
-      def config_init_logger: () -> Datadog::Core::Logger
+      def config_init_logger: (?String debug_source_value) -> Datadog::Core::Logger
 
       def shutdown!: -> void
     end
diff --git a/sig/datadog/core/configuration/stable_config.rbs b/sig/datadog/core/configuration/stable_config.rbs
@@ -3,7 +3,11 @@ module Datadog
     module Configuration
       module StableConfig
 
-        type stable_config = Hash[Symbol, Hash[String, String]]
+        type stable_config = {
+          ?logs: String?,
+          ?local: Hash[String, String],
+          ?fleet: Hash[String, String]
+        }
 
         class Configurator
           def initialize: -> void
diff --git a/spec/datadog/core/configuration/stable_config_spec.rb b/spec/datadog/core/configuration/stable_config_spec.rb
@@ -18,32 +18,36 @@
   describe '#configuration', skip: !LibdatadogHelpers.supported? do
     let(:tmpdir) { Dir.mktmpdir }
     before do
+      Datadog::Core::Configuration::StableConfig.instance_variable_set(:@configuration, nil)
+
       File.write(
         File.join(tmpdir, 'local_config.yaml'),
         local_config_content
-      )
+      ) if defined?(local_config_content)
       File.write(
         File.join(tmpdir, 'fleet_config.yaml'),
         fleet_config_content
-      )
+      ) if defined?(fleet_config_content)
 
       test_configurator = Datadog::Core::Configuration::StableConfig::Configurator.new
       Datadog::Core::Configuration::StableConfig::Testing.with_local_path(
         test_configurator,
         File.join(tmpdir, 'local_config.yaml')
-      )
+      ) if defined?(local_config_content)
       Datadog::Core::Configuration::StableConfig::Testing.with_fleet_path(
         test_configurator,
         File.join(tmpdir, 'fleet_config.yaml')
-      )
+      ) if defined?(fleet_config_content)
 
-      allow(Datadog::Core::Configuration::StableConfig).to receive(:extract_configuration).and_return(
+      allow_any_instance_of(Datadog::Core::Configuration::StableConfig::Configurator).to receive(:get).and_return(
         test_configurator.get
       )
     end
 
     after do
       FileUtils.remove_entry_secure(tmpdir)
+
+      Datadog::Core::Configuration::StableConfig.instance_variable_set(:@configuration, nil)
     end
 
     context 'when libdatadog API is available' do
@@ -65,12 +69,13 @@
         end
 
         it 'returns the configuration' do
-          expect(described_class.configuration).to eq(
+          expect(described_class.configuration).to include(
             {
               local: {id: "12345", config: {"DD_LOGS_INJECTION" => "false"}},
               fleet: {id: "56789", config: {"DD_APPSEC_ENABLED" => "true"}}
             }
           )
+          expect(described_class.configuration[:logs]).to be_a(String)
         end
       end
 
@@ -90,12 +95,84 @@
         end
 
         it 'returns the configuration' do
-          expect(described_class.configuration).to eq(
+          expect(described_class.configuration).to include(
             {
               local: {config: {"DD_LOGS_INJECTION" => "false"}},
               fleet: {config: {"DD_APPSEC_ENABLED" => "true"}}
             }
           )
+          expect(described_class.configuration[:logs]).to be_a(String)
+        end
+      end
+
+      context 'with DD_TRACE_DEBUG set during configuration initialization' do
+        # Global configuration has already been set up before the test, so we need to simulate that it was not set up
+        # Same for temporary logger
+        before do
+          allow(Datadog).to receive(:configuration?).and_return(false)
+          Datadog.instance_variable_set(:@temp_config_logger, nil)
+        end
+
+        after do
+          Datadog.instance_variable_set(:@temp_config_logger, nil)
+        end
+
+        context 'to true in fleet config' do
+          let(:fleet_config_content) do
+            <<~YAML
+            apm_configuration_default:
+              DD_TRACE_DEBUG: true
+            YAML
+          end
+
+          it 'prints debug logs' do
+            expect { described_class.configuration }.to output(/Reading stable configuration from files/).to_stdout
+          end
+        end
+
+        context 'to true in env' do
+          around do |example|
+            ClimateControl.modify(Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED => 'true') do
+              example.run
+            end
+          end
+
+          it 'prints debug logs' do
+            expect { described_class.configuration }.to output(/Reading stable configuration from files/).to_stdout
+          end
+        end
+
+        context 'to true in local config' do
+          let(:local_config_content) do
+            <<~YAML
+            apm_configuration_default:
+              DD_TRACE_DEBUG: true
+            YAML
+          end
+
+          it 'prints debug logs' do
+            expect { described_class.configuration }.to output(/Reading stable configuration from files/).to_stdout
+          end
+        end
+
+        context 'to true in local config and false in fleet config' do
+          let(:local_config_content) do
+            <<~YAML
+            apm_configuration_default:
+              DD_TRACE_DEBUG: true
+            YAML
+          end
+
+          let(:fleet_config_content) do
+            <<~YAML
+            apm_configuration_default:
+              DD_TRACE_DEBUG: false
+            YAML
+          end
+        end
+
+        it 'respects priority and does not print debug logs' do
+          expect { described_class.configuration }.not_to output(/Reading stable configuration from files/).to_stdout
         end
       end
     end
diff --git a/spec/datadog/core/configuration_spec.rb b/spec/datadog/core/configuration_spec.rb
@@ -448,20 +448,25 @@
     end
 
     describe '#logger_without_configuration' do
-      subject(:logger_without_configuration) { test_class.send(:logger_without_configuration) }
-      context 'when configuration is not initialized and DD_TRACE_DEBUG is not set' do
+      subject(:logger_without_configuration) { test_class.send(:logger_without_configuration, debug_source_value) }
+
+      context 'when configuration is not initialized and debug_source_value is not set' do
+        let(:debug_source_value) { nil }
+
         it { expect(logger_without_configuration.level).to be ::Logger::INFO }
       end
 
-      context 'when configuration is not initialized and DD_TRACE_DEBUG is set' do
-        around do |example|
-          ClimateControl.modify('DD_TRACE_DEBUG' => 'true') do
-            example.run
-          end
-        end
+      context 'when configuration is not initialized and debug_source_value is set to true' do
+        let(:debug_source_value) { 'true' }
 
         it { expect(logger_without_configuration.level).to be ::Logger::DEBUG }
       end
+
+      context 'when configuration is not initialized and debug_source_value is set to false' do
+        let(:debug_source_value) { 'false' }
+
+        it { expect(logger_without_configuration.level).to be ::Logger::INFO }
+      end
     end
 
     describe '#runtime_metrics' do
