swap out the existing headers normalization logic with the tag normalizer

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,51 @@
+# 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,34 @@
+# frozen_string_literal: true
+
+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.squeeze!('_')
+        # 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/metadata/ext.rb

@@ -120,20 +120,8 @@ module Headers
             # By default, tags cannot create nested span tag levels:
             # `allow_nested` allows you to override this behavior.
             def to_tag(name, allow_nested: false)
-              # Tag normalization based on: https://docs.datadoghq.com/getting_started/tagging/#defining-tags.
-              #
-              # Only the following characters are accepted.
-              #  * Alphanumerics
-              #  * Underscores
-              #  * Minuses
-              #  * Colons
-              #  * Periods
-              #  * Slashes
-              #
-              # All other characters are replaced with an underscore.
-              tag = name.to_s.strip
-              tag.downcase!
-              tag.gsub!(INVALID_TAG_CHARACTERS, '_')
+              # Reuse the tag normalization logic from the Core::Normalizer module
+              tag = Core::Normalizer.normalize(name)
 
               # Additional HTTP header normalization.
               #

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?

sig/datadog/core/environment/ext.rbs

@@ -37,6 +37,18 @@ module Datadog
         TAG_SERVICE: String
 
         TAG_VERSION: String
+
+        PROCESS_TYPE: String
+
+        TAG_ENTRYPOINT_BASEDIR: String
+
+        TAG_ENTRYPOINT_NAME: String
+
+        TAG_ENTRYPOINT_WORKDIR: String
+
+        TAG_ENTRYPOINT_TYPE: String
+
+        TAG_PROCESS_TAGS: String
       end
     end
   end

sig/datadog/core/environment/process.rbs

@@ -0,0 +1,19 @@
+module Datadog
+  module Core
+    module Environment
+      module Process
+        @serialized: untyped
+
+        def self?.entrypoint_workdir: () -> untyped
+
+        def self?.entrypoint_type: () -> untyped
+
+        def self?.entrypoint_name: () -> untyped
+
+        def self?.entrypoint_basedir: () -> untyped
+        def self?.serialized_kv_helper: (untyped key, untyped value) -> ::String
+        def self?.serialized: () -> untyped
+      end
+    end
+  end
+end

sig/datadog/core/normalizer.rbs

@@ -0,0 +1,8 @@
+module Datadog
+  module Core
+    module Normalizer
+      INVALID_TAG_CHARACTERS: ::Regexp
+      def self.normalize: (untyped original_value) -> ("" | untyped)
+    end
+  end
+end

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-active-record --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/metadata/ext_spec.rb

@@ -26,15 +26,16 @@
       let(:tag) { '_-:/' }
 
       it 'preserves them' do
-        is_expected.to eq(tag)
+        is_expected.to eq("")
       end
     end
 
     context 'with unsupported characters' do
       let(:tag) { "\\ \t!@?" }
 
       it 'replaces each with an underscore' do
-        is_expected.to eq('_' * tag.size)
+        # turns into an empty string because in a tag, the first character must be a letter
+        is_expected.to eq('')
       end
     end