feat: add process tags to traces

lib/datadog/core/configuration/settings.rb

@@ -1003,6 +1003,16 @@ def initialize(*_)
           end
         end
 
+        # Enable experimental process tags propagation.
+        #
+        # @default `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable, otherwise `false`
+        # @return [Boolean]
+        option :experimental_propagate_process_tags_enabled do |o|
+          o.env 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
+          o.default false
+          o.type :bool
+        end
+
         # Tracer specific configuration starting with APM (e.g. DD_APM_TRACING_ENABLED).
         # @public_api
         settings :apm do

lib/datadog/core/configuration/supported_configurations.rb

@@ -43,6 +43,7 @@ module Configuration
          "DD_ENV" => {version: ["A"]},
          "DD_ERROR_TRACKING_HANDLED_ERRORS" => {version: ["A"]},
          "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE" => {version: ["A"]},
+         "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED" => {version: ["A"]},
          "DD_GIT_COMMIT_SHA" => {version: ["A"]},
          "DD_GIT_REPOSITORY_URL" => {version: ["A"]},
          "DD_HEALTH_METRICS_ENABLED" => {version: ["A"]},

lib/datadog/core/environment/ext.rb

@@ -33,8 +33,14 @@ module Ext
         LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}"
         LANG_PLATFORM = RUBY_PLATFORM
         LANG_VERSION = RUBY_VERSION
+        PROCESS_TYPE = 'script'
         RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
         TAG_ENV = 'env'
+        TAG_ENTRYPOINT_BASEDIR = "entrypoint.basedir"
+        TAG_ENTRYPOINT_NAME = "entrypoint.name"
+        TAG_ENTRYPOINT_WORKDIR = "entrypoint.workdir"
+        TAG_ENTRYPOINT_TYPE = "entrypoint.type"
+        TAG_PROCESS_TAGS = "_dd.tags.process"
         TAG_SERVICE = 'service'
         TAG_VERSION = 'version'
 

lib/datadog/core/environment/process.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require_relative 'ext'
+require_relative '../normalizer'
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves process level information
+      module Process
+        module_function
+
+        def entrypoint_workdir
+          File.basename(Dir.pwd)
+        end
+
+        def entrypoint_type
+          Core::Environment::Ext::PROCESS_TYPE
+        end
+
+        def entrypoint_name
+          File.basename($0)
+        end
+
+        def entrypoint_basedir
+          current_basedir = File.expand_path(File.dirname($0))
+          normalized_basedir = current_basedir.tr(File::SEPARATOR, '/')
+          normalized_basedir.delete_prefix!('/')
+        end
+
+        # Normalize tag key and value using the Datadog Agent's tag normalization logic
+        def serialized_kv_helper(key, value)
+          key = Core::Normalizer.normalize(key)
+          value = Core::Normalizer.normalize(value)
+          "#{key}:#{value}"
+        end
+
+        # This method returns a key/value part of serialized tags in the format of k1:v1,k2:v2,k3:v3
+        def serialized
+          return @serialized if defined?(@serialized)
+          tags = []
+          tags << serialized_kv_helper(Core::Environment::Ext::TAG_ENTRYPOINT_WORKDIR, entrypoint_workdir) if entrypoint_workdir
+          tags << serialized_kv_helper(Core::Environment::Ext::TAG_ENTRYPOINT_NAME, entrypoint_name) if entrypoint_name
+          tags << serialized_kv_helper(Core::Environment::Ext::TAG_ENTRYPOINT_BASEDIR, entrypoint_basedir) if entrypoint_basedir
+          tags << serialized_kv_helper(Core::Environment::Ext::TAG_ENTRYPOINT_TYPE, entrypoint_type) if entrypoint_type
+          @serialized = tags.join(',').freeze
+        end
+      end
+    end
+  end
+end

lib/datadog/core/normalizer.rb

@@ -0,0 +1,31 @@
+module Datadog
+  module Core
+    module Normalizer
+      module_function
+      INVALID_TAG_CHARACTERS = %r{[^a-z0-9_\-:./]}.freeze
+
+      # Based on https://docs.datadoghq.com/getting_started/tagging/#defining-tags
+      # Currently a reimplementation of the logic in the 
+      # Datadog::Tracing::Metadata::Ext::HTTP::Headers.to_tag method with some additional items
+      # TODO: Swap out the logic in the Datadog Tracing Metadata headers logic
+      def self.normalize(original_value)
+        return "" if original_value.nil? || original_value.to_s.strip.empty?
+
+        # Removes whitespaces
+        normalized_value = original_value.to_s.strip
+        # Lower case characters
+        normalized_value.downcase!
+        # Invalid characters are replaced with an underscore
+        normalized_value.gsub!(INVALID_TAG_CHARACTERS, '_')
+        # Merge consecutive underscores with a single underscore
+        normalized_value.gsub!(/_+/, '_')
+        # Remove leading non-letter characters
+        normalized_value.sub!(/\A[^a-z]+/, "")
+        # Maximum length is 200 characters
+        normalized_value = normalized_value[0...200] if normalized_value.length > 200
+
+        normalized_value
+      end
+    end
+  end
+end

lib/datadog/tracing/configuration/ext.rb

@@ -15,6 +15,7 @@ module Ext
         ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
         ENV_RESOURCE_RENAMING_ENABLED = 'DD_TRACE_RESOURCE_RENAMING_ENABLED'
         ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = 'DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT'
+        ENV_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
 
         # @public_api
         module SpanAttributeSchema

lib/datadog/tracing/transport/trace_formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/environment/identity'
+require_relative '../../core/environment/process'
 require_relative '../../core/environment/socket'
 require_relative '../../core/environment/git'
 require_relative '../../core/git/ext'
@@ -60,6 +61,7 @@ def format!
           tag_sampling_priority!
           tag_profiling_enabled!
           tag_apm_tracing_disabled!
+          tag_process_tags!
 
           if first_span
             tag_git_repository_url!
@@ -215,6 +217,12 @@ def tag_git_commit_sha!
           first_span.set_tag(Core::Git::Ext::TAG_COMMIT_SHA, git_commit_sha)
         end
 
+        def tag_process_tags!
+          return unless Datadog.configuration.experimental_propagate_process_tags_enabled
+          process_tags = Core::Environment::Process.serialized
+          first_span.set_tag(Core::Environment::Ext::TAG_PROCESS_TAGS, process_tags)
+        end
+
         private
 
         def partial?

spec/datadog/core/environment/process_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'datadog/core/environment/process'
+require 'open3'
+
+RSpec.describe Datadog::Core::Environment::Process do
+  describe '::entrypoint_workdir' do
+    subject(:entrypoint_workdir) { described_class.entrypoint_workdir }
+
+    it { is_expected.to be_a_kind_of(String) }
+  end
+
+  describe '::entrypoint_type' do
+    subject(:entrypoint_type) { described_class.entrypoint_type }
+
+    it { is_expected.to be_a_kind_of(String) }
+    it { is_expected.to eq(Datadog::Core::Environment::Ext::PROCESS_TYPE) }
+  end
+
+  describe '::entrypoint_name' do
+    subject(:entrypoint_name) { described_class.entrypoint_name }
+
+    it { is_expected.to be_a_kind_of(String) }
+  end
+
+  describe '::entrypoint_basedir' do
+    subject(:entrypoint_basedir) { described_class.entrypoint_basedir }
+
+    it { is_expected.to be_a_kind_of(String) }
+  end
+
+  describe '::serialized' do
+    subject(:serialized) { described_class.serialized }
+
+    it { is_expected.to be_a_kind_of(String) }
+
+    it 'returns the same object when called multiple times' do
+      # Processes are fixed so no need to recompute this on each call
+      first_call = described_class.serialized
+      second_call = described_class.serialized
+      expect(first_call).to equal(second_call)
+    end
+  end
+
+  describe 'Scenario: Real applications' do
+    context 'when running a real Rails application' do
+      it 'detects Rails process information correctly' do
+        Dir.mktmpdir do |tmp_dir|
+          Dir.chdir(tmp_dir) do
+            Bundler.with_unbundled_env do
+              skip('rails gem could not be installed') unless system('gem install rails')
+              unless system('rails new test_app --minimal --skip-test --skip-keeps --skip-git --skip-docker')
+                skip('rails new command failed')
+              end
+            end
+          end
+          File.open("#{tmp_dir}/test_app/Gemfile", 'a') do |file|
+            file.puts "gem 'datadog', path: '#{Dir.pwd}', require: false"
+          end
+          File.write("#{tmp_dir}/test_app/config/initializers/process_initializer.rb", <<-RUBY)
+                      Rails.application.config.after_initialize do
+                          require 'datadog/core/environment/process'
+                          STDERR.puts "entrypoint_workdir:\#{Datadog::Core::Environment::Process.entrypoint_workdir}"
+                          STDERR.puts "entrypoint_type:\#{Datadog::Core::Environment::Process.entrypoint_type}"
+                          STDERR.puts "entrypoint_name:\#{Datadog::Core::Environment::Process.entrypoint_name}"
+                          STDERR.puts "entrypoint_basedir:\#{Datadog::Core::Environment::Process.entrypoint_basedir}"
+                          STDERR.puts "_dd.tags.process:\#{Datadog::Core::Environment::Process.serialized}"
+                          STDERR.flush
+                          Thread.new { sleep 1; Process.kill('TERM', Process.pid)}#{' '}
+                      end
+          RUBY
+          Bundler.with_unbundled_env do
+            Dir.chdir("#{tmp_dir}/test_app") do
+              _, _, _ = Open3.capture3('bundle install')
+              _, err, _ = Open3.capture3('bundle exec rails s')
+              expect(err).to include('entrypoint_workdir:test_app')
+              expect(err).to include('entrypoint_type:script')
+              expect(err).to include('entrypoint_name:rails')
+              basedir_test = tmp_dir.sub(%r{^/}, '')
+              expect(err).to include("entrypoint_basedir:#{basedir_test}/test_app/bin")
+              expected_tags = "entrypoint.workdir:test_app,entrypoint.name:rails,entrypoint.basedir:#{basedir_test}/test_app/bin,entrypoint.type:script"
+              expect(err).to include("_dd.tags.process:#{expected_tags}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

spec/datadog/core/normalizer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'datadog/core/normalizer'
+
+RSpec.describe Datadog::Core::Normalizer do
+  describe '.normalize' do
+    subject(:normalize) { described_class.normalize(input) }
+
+    context 'keeps normal strings the same' do
+        let(:input) {'regulartag'}
+        let(:expected_output) {'regulartag'}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'truncates long strings' do
+        let(:input) {'a' * 201}
+        let(:expected_output) {'a' * 200}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'transforms special characters to underscores' do
+        let(:input) {'a&**!'}
+        let(:expected_output) {'a_'}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'capital letters are lower cased' do
+        let(:input) {'A'*10}
+        let(:expected_output) {'a'*10}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'removes whitespaces' do
+        let(:input) {'  hi  '}
+        let(:expected_output) {'hi'}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'characters must start with a letter' do
+        let(:input) {'1hi'}
+        let(:expected_output) {'hi'}
+        it { is_expected.to eq(expected_output) }
+    end
+
+    context 'if none of the characters are valid to start the value, the string is empty' do
+        let(:input) {'111111111'}
+        let(:expected_output) {''}
+        it { is_expected.to eq(expected_output) }
+    end
+  end
+end

spec/datadog/tracing/transport/trace_formatter_spec.rb

@@ -237,6 +237,23 @@
         end
       end
 
+      shared_examples 'first span with process tags' do
+        it do
+          format!
+          expect(first_span.meta).to include('_dd.tags.process')
+          expect(first_span.meta['_dd.tags.process']).to eq(Datadog::Core::Environment::Process.serialized)
+          # TODO figure out if we need an assertion for the value, ie
+          # `"entrypoint.workdir:app,entrypoint.name:rspec,entrypoint.basedir:usr/local/bundle/bin,entrypoint.type:script,server.type:placeholder"`
+        end
+      end
+
+      shared_examples 'first span without process tags' do
+        it do
+          format!
+          expect(first_span.meta).to_not include('_dd.tags.process')
+        end
+      end
+
       context 'with no root span' do
         include_context 'no root span'
 
@@ -284,6 +301,18 @@
           include_context 'no git metadata'
           it_behaves_like 'first span with no git metadata'
         end
+
+        context 'with process tags enabled' do
+          before do
+            allow(Datadog.configuration).to receive(:experimental_propagate_process_tags_enabled).and_return(true)
+          end
+          it_behaves_like 'first span with process tags'
+        end
+
+        context 'without process tags enabled' do
+          # default is false
+          it_behaves_like 'first span without process tags'
+        end
       end
 
       context 'with missing root span' do
@@ -333,6 +362,18 @@
           include_context 'no git metadata'
           it_behaves_like 'first span with no git metadata'
         end
+
+        context 'with process tags enabled' do
+          before do
+            allow(Datadog.configuration).to receive(:experimental_propagate_process_tags_enabled).and_return(true)
+          end
+          it_behaves_like 'first span with process tags'
+        end
+
+        context 'without process tags enabled' do
+          # default is false
+          it_behaves_like 'first span without process tags'
+        end
       end
 
       context 'with a root span' do
@@ -384,6 +425,18 @@
           include_context 'no git metadata'
           it_behaves_like 'first span with no git metadata'
         end
+
+        context 'with process tags enabled' do
+          before do
+            allow(Datadog.configuration).to receive(:experimental_propagate_process_tags_enabled).and_return(true)
+          end
+          it_behaves_like 'first span with process tags'
+        end
+
+        context 'without process tags enabled' do
+          # default is false
+          it_behaves_like 'first span without process tags'
+        end
       end
     end
   end

supported-configurations.json

@@ -109,6 +109,9 @@
     "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE": {
       "version": ["A"]
     },
+    "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": {
+      "version": ["A"]
+    },
     "DD_GIT_COMMIT_SHA": {
       "version": ["A"]
     },