enable process tags to true by default (#5432)

* Set the default of DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED to true and adjust tests

* Remove the process tags from the remote client payload since it is not needed for the test

* Adjust DBM tests for the new default true setting

* Adjust telemetry payload in tests due to the new default

* Fix another dbm test for the true default for process tag

* Add the process tags payload to the remote config payload in tests since it defaults to true now

* Change supported-configurations.json from A to B

* Remove fallback for runtime metrics and update runtime metrics tests to match

* Simplify the settings_spec test per review

* Bring back tags and process_tags when testing remote client_spec

* Adjust telemetry tests to start off with the assumption that process tags are disabled to avoid mixing testing concerns

* Update spec/datadog/core/workers/runtime_metrics_spec.rb

Co-authored-by: Munir Abdinur <munir.abdinur@datadoghq.com>

* Refactor runtime_metrics_spec.rb to use receive syntax

* Add an internal alias for propagate_process_tags_enabled that doesn't include experimental and adjust specs to match

* Add missing test

* Add back the experimental designation so it can be deleted later

---------

Co-authored-by: Munir Abdinur <munir.abdinur@datadoghq.com>

Author: wantsui

lib/datadog/core/configuration/settings.rb

@@ -1057,13 +1057,13 @@ def initialize(*_)
           end
         end
 
-        # Enable experimental process tags propagation such that payloads like spans contain the process tag.
+        # Enable process tags propagation such that payloads like spans contain the process tag.
         #
-        # @default `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable, otherwise `false`
+        # @default `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable, otherwise `true`
         # @return [Boolean]
         option :experimental_propagate_process_tags_enabled do |o|
           o.env 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
-          o.default false
+          o.default true
           o.type :bool
         end
 

lib/datadog/core/runtime/metrics.rb

@@ -26,8 +26,7 @@ def initialize(telemetry:, **options)
           # Initialize the collection of runtime-id
           @runtime_id_enabled = options.fetch(:experimental_runtime_id_enabled, false)
 
-          # Initialized process tags support
-          @process_tags_enabled = options.fetch(:experimental_propagate_process_tags_enabled, false)
+          @process_tags_enabled = options.fetch(:experimental_propagate_process_tags_enabled)
         end
 
         # Associate service with runtime metrics

lib/datadog/core/workers/runtime_metrics.rb

@@ -21,7 +21,15 @@ class RuntimeMetrics < Worker
           :metrics
 
         def initialize(telemetry:, **options)
-          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new(logger: options[:logger], telemetry: telemetry) }
+          @metrics = options.fetch(:metrics) do
+            Core::Runtime::Metrics.new(
+              logger: options[:logger],
+              telemetry: telemetry,
+              experimental_propagate_process_tags_enabled: options.fetch(:propagate_process_tags_enabled) do
+                options.fetch(:experimental_propagate_process_tags_enabled)
+              end
+            )
+          end
 
           # Workers::Async::Thread settings
           self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)

spec/datadog/core/configuration/settings_spec.rb

@@ -1407,39 +1407,17 @@
   describe '#experimental_propagate_process_tags_enabled' do
     subject(:experimental_propagate_process_tags_enabled) { settings.experimental_propagate_process_tags_enabled }
 
-    context "when #{Datadog::Core::Environment::Ext::ENV_VERSION}" do
-      around do |example|
-        ClimateControl.modify('DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED' => environment) do
-          example.run
-        end
-      end
-
-      context 'by default' do
-        let(:environment) { nil }
-
-        it { is_expected.to be false }
-      end
-
-      context 'when set to true' do
-        let(:environment) { 'true' }
-
-        it { is_expected.to be true }
-      end
-
-      context 'when set to false' do
-        let(:environment) { 'false' }
-
-        it { is_expected.to be false }
-      end
-    end
+    it_behaves_like 'a binary setting with',
+      env_variable: 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED',
+      default: true
   end
 
   describe '#experimental_propagate_process_tags_enabled=' do
     it 'updates the #experimental_propagate_process_tags_enabled setting' do
-      expect { settings.experimental_propagate_process_tags_enabled = true }
+      expect { settings.experimental_propagate_process_tags_enabled = false }
         .to change { settings.experimental_propagate_process_tags_enabled }
-        .from(false)
-        .to(true)
+        .from(true)
+        .to(false)
     end
   end
 

spec/datadog/core/crashtracking/tag_builder_spec.rb

@@ -127,6 +127,10 @@
       end
 
       context 'when process tags propagation is not enabled' do
+        before do
+          settings.experimental_propagate_process_tags_enabled = false
+        end
+
         it 'does not include process tags in the crash tracking payload' do
           expect(call.keys).to_not include('process_tags')
         end

spec/datadog/core/remote/client_spec.rb

@@ -640,7 +640,7 @@
                   env: settings.env,
                 }
 
-                expect(client_payload[:client_tracer].tap { |h| h.delete(:tags) }).to eq(expected_client_tracer)
+                expect(client_payload[:client_tracer]).to include(expected_client_tracer)
               end
             end
 
@@ -657,7 +657,7 @@
                   app_version: settings.version,
                 }
 
-                expect(client_payload[:client_tracer].tap { |h| h.delete(:tags) }).to eq(expected_client_tracer)
+                expect(client_payload[:client_tracer]).to include(expected_client_tracer)
               end
             end
 
@@ -673,7 +673,7 @@
                   env: settings.env,
                 }
 
-                expect(client_payload[:client_tracer].tap { |h| h.delete(:tags) }).to eq(expected_client_tracer)
+                expect(client_payload[:client_tracer]).to include(expected_client_tracer)
               end
             end
           end
@@ -699,7 +699,11 @@
           end
 
           context 'when process tags propagation is not enabled' do
-            # Currently false by default
+            before do
+              # Explicitly disable because the global default is now true.
+              allow(settings).to receive(:experimental_propagate_process_tags_enabled).and_return(false)
+            end
+
             it 'does not have process tags in the payload' do
               expect(client_payload[:client_tracer]).not_to have_key(:process_tags)
             end

spec/datadog/core/runtime/metrics_spec.rb

@@ -6,7 +6,7 @@
 RSpec.describe Datadog::Core::Runtime::Metrics do
   let(:logger) { logger_allowing_debug }
   let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
-  let(:options) { {} }
+  let(:options) { {experimental_propagate_process_tags_enabled: true} }
   subject(:runtime_metrics) { described_class.new(logger: logger, telemetry: telemetry, **options) }
 
   describe '::new' do
@@ -325,6 +325,18 @@
     describe ':tags' do
       subject(:default_tags) { default_metric_options[:tags] }
 
+      context 'when :experimental_propagate_process_tags_enabled is true' do
+        before do
+          allow(Datadog::Core::Environment::Process).to receive(:tags)
+            .and_return(['entrypoint.workdir:test', 'entrypoint.name:test_script'])
+        end
+
+        it 'includes process tags by default' do
+          is_expected.to include('entrypoint.workdir:test')
+          is_expected.to include('entrypoint.name:test_script')
+        end
+      end
+
       context 'given :experimental_runtime_id_enabled' do
         let(:options) { super().merge(experimental_runtime_id_enabled: runtime_id_enabled) }
         let(:runtime_id_enabled) { true }

spec/datadog/core/telemetry/integration/telemetry_spec.rb

@@ -57,6 +57,7 @@
         'env' => nil,
         'language_name' => 'ruby',
         'language_version' => String,
+        'process_tags' => String,
         'runtime_name' => /\Aj?ruby\z/i,
         'runtime_version' => String,
         'service_name' => String,

spec/datadog/core/telemetry/request_spec.rb

@@ -37,6 +37,7 @@
     let(:service_name) { 'service' }
     let(:service_version) { 'version' }
     let(:tracer_version) { Datadog::Core::Environment::Identity.gem_datadog_version_semver2 }
+    let(:process_tags_enabled) { false }
 
     let(:host) do
       {
@@ -59,21 +60,47 @@
         c.env = env
         c.service = service_name
         c.version = service_version
+        c.experimental_propagate_process_tags_enabled = process_tags_enabled
       end
     end
 
-    it do
-      is_expected.to match(
-        api_version: api_version,
-        application: application,
-        debug: debug,
-        host: host,
-        payload: payload,
-        request_type: request_type,
-        runtime_id: runtime_id,
-        seq_id: seq_id,
-        tracer_time: be_between(before_time, after_time),
-      )
+    context 'when process tags propagation is disabled' do
+      it do
+        is_expected.to match(
+          api_version: api_version,
+          application: application,
+          debug: debug,
+          host: host,
+          payload: payload,
+          request_type: request_type,
+          runtime_id: runtime_id,
+          seq_id: seq_id,
+          tracer_time: be_between(before_time, after_time),
+        )
+      end
+    end
+
+    context 'when process tags propagation is enabled' do
+      let(:process_tags_enabled) { true }
+      let(:process_tags) { 'entrypoint.workdir:test,entrypoint.name:test_script' }
+
+      before do
+        allow(Datadog::Core::Environment::Process).to receive(:serialized).and_return(process_tags)
+      end
+
+      it do
+        is_expected.to match(
+          api_version: api_version,
+          application: application.merge(process_tags: process_tags),
+          debug: debug,
+          host: host,
+          payload: payload,
+          request_type: request_type,
+          runtime_id: runtime_id,
+          seq_id: seq_id,
+          tracer_time: be_between(before_time, after_time),
+        )
+      end
     end
 
     context 'when Datadog::CI is loaded and ci mode is enabled' do

spec/datadog/core/workers/runtime_metrics_spec.rb

@@ -20,12 +20,27 @@
     it { expect(worker).to be_a_kind_of(Datadog::Core::Workers::Polling) }
 
     context 'by default' do
-      subject(:worker) { described_class.new(logger: logger, telemetry: telemetry) }
+      subject(:worker) do
+        described_class.new(
+          logger: logger,
+          telemetry: telemetry,
+          experimental_propagate_process_tags_enabled: true
+        )
+      end
 
       it { expect(worker.enabled?).to be false }
       it { expect(worker.loop_base_interval).to eq 10 }
       it { expect(worker.loop_back_off_ratio).to eq 1.2 }
       it { expect(worker.loop_back_off_max).to eq 30 }
+      it 'builds runtime metrics with process tags propagation setting' do
+        expect(Datadog::Core::Runtime::Metrics).to receive(:new).with(
+          logger: logger,
+          telemetry: telemetry,
+          experimental_propagate_process_tags_enabled: true,
+        ).and_call_original
+
+        worker
+      end
     end
 
     context 'when :enabled is given' do