datadog 2.22.0 → 2.23.0

data/lib/datadog/core/ddsketch.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'datadog/core'
-
 module Datadog
   module Core
     # Used to access ddsketch APIs.

data/lib/datadog/core/environment/ext.rb

@@ -33,8 +33,14 @@ module Datadog
         LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}"
         LANG_PLATFORM = RUBY_PLATFORM
         LANG_VERSION = RUBY_VERSION
+        PROCESS_TYPE = 'script' # Out of the options [jar, script, class, executable], we consider Ruby to always be a 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'
 

data/lib/datadog/core/environment/process.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative '../tag_normalizer'
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves process level information such that it can be attached to various payloads
+      #
+      # @api private
+      module Process
+        # This method returns a key/value part of serialized tags in the format of k1:v1,k2:v2,k3:v3
+        # @return [String] comma-separated normalized key:value pairs
+        def self.serialized
+          return @serialized if defined?(@serialized)
+          tags = []
+
+          workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_WORKDIR}:#{workdir}" unless workdir.empty?
+
+          entry_name = TagNormalizer.normalize_process_value(entrypoint_name.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_NAME}:#{entry_name}" unless entry_name.empty?
+
+          basedir = TagNormalizer.normalize_process_value(entrypoint_basedir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_BASEDIR}:#{basedir}" unless basedir.empty?
+
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
+
+          @serialized = tags.join(',').freeze
+        end
+
+        # Returns the last segment of the working directory of the process
+        # Example: /app/myapp -> myapp
+        # @return [String] the last segment of the working directory
+        def self.entrypoint_workdir
+          File.basename(Dir.pwd)
+        end
+
+        # Returns the entrypoint type of the process
+        # In Ruby, the entrypoint type is always 'script'
+        # @return [String] the type of the process, which is fixed in Ruby
+        def self.entrypoint_type
+          Environment::Ext::PROCESS_TYPE
+        end
+
+        # Returns the last segment of the base directory of the process
+        # Example 1: /bin/mybin -> mybin
+        # Example 2: ruby /test/myapp.rb -> myapp
+        # @return [String] the last segment of base directory of the script
+        #
+        # @note Determining true entrypoint name is rather complicated. This method
+        # is the initial implementation but it does not produce optimal output in all cases.
+        # For example, all Rails applications launched via `rails server` get `rails`
+        # as their entrypoint name.
+        # We might improve the behavior in the future if there is customer demand for it.
+        def self.entrypoint_name
+          File.basename($0)
+        end
+
+        # Returns the last segment of the base directory of the process
+        # Example 1: /bin/mybin -> bin
+        # Example 2: ruby /test/myapp.js -> test
+        # @return [String] the last segment of the base directory of the script
+        #
+        # @note As with entrypoint name, determining true entrypoint directory is complicated.
+        # This method has an initial implementation that does not necessarily return good
+        # results in all cases. For example, for Rails applications launched via `rails server`
+        # the entrypoint basedir is `bin` which is not very helpful.
+        # We might improve this in the future if there is customer demand.
+        def self.entrypoint_basedir
+          File.basename(File.expand_path(File.dirname($0)))
+        end
+
+        private_class_method :entrypoint_workdir, :entrypoint_type, :entrypoint_name, :entrypoint_basedir
+      end
+    end
+  end
+end

data/lib/datadog/core/feature_flags.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module Core
+    # Feature flags evaluation using libdatadog
+    # The classes in this module are defined as C extensions in ext/libdatadog_api/feature_flags.c
+    #
+    # @api private
+    module FeatureFlags
+      # A top-level error raised by the extension
+      class Error < StandardError # rubocop:disable Lint/EmptyClass
+      end
+
+      # Configuration for feature flags evaluation
+      # This class is defined in the C extension
+      class Configuration # rubocop:disable Lint/EmptyClass
+      end
+
+      # Resolution details for a feature flag evaluation
+      # Base class is defined in the C extension, with Ruby methods added here
+      class ResolutionDetails
+        attr_writer :value
+
+        # Get the resolved value, with JSON parsing for object types
+        #
+        # @return [Object] The resolved value (parsed from JSON if object type)
+        # @raise [Datadog::Core::FeatureFlags::Error] If JSON parsing fails
+        def value
+          return @value if defined?(@value)
+
+          # NOTE: Raw value method call doesn't support memoization right now
+          value = raw_value
+
+          # NOTE: Lazy parsing of the JSON is a temporary solution and will be
+          #       moved into C extension
+          @value = json?(value) ? JSON.parse(value) : value
+        rescue JSON::ParserError => e
+          raise Error, "Failed to parse JSON value: #{e.class}: #{e}"
+        end
+
+        # Check if the resolution resulted in an error
+        #
+        # @return [Boolean] True if there was an error
+        def error?
+          reason == 'ERROR'
+        end
+
+        private
+
+        # NOTE: A JSON raw string will be returned by the `libdatadog` as
+        #       a Ruby String class with a flag type `:object`, otherwise it's
+        #       just a string.
+        def json?(value)
+          flag_type == :object && value.is_a?(String)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote/client/capabilities.rb

@@ -3,6 +3,7 @@
 require_relative '../../utils/base64'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
+require_relative '../../../open_feature/remote'
 
 module Datadog
   module Core
@@ -38,6 +39,12 @@ module Datadog
               register_receivers(Datadog::DI::Remote.receivers(@telemetry))
             end
 
+            if settings.respond_to?(:open_feature) && settings.open_feature.enabled
+              register_capabilities(Datadog::OpenFeature::Remote.capabilities)
+              register_products(Datadog::OpenFeature::Remote.products)
+              register_receivers(Datadog::OpenFeature::Remote.receivers(@telemetry))
+            end
+
             register_capabilities(Datadog::Tracing::Remote.capabilities)
             register_products(Datadog::Tracing::Remote.products)
             register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))

data/lib/datadog/core/remote/transport/config.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../../core/transport/request'
 require_relative '../../../core/transport/parcel'
+require_relative 'http/config'
 
 module Datadog
   module Core
@@ -21,15 +22,6 @@ module Datadog
           class Request < Datadog::Core::Transport::Request
           end
 
-          # Config response
-          module Response
-            attr_reader :roots, :targets, :target_files, :client_configs
-
-            def empty?
-              @empty
-            end
-          end
-
           # Config transport
           class Transport
             attr_reader :client, :apis, :default_api, :current_api_id, :logger
@@ -38,7 +30,7 @@ module Datadog
               @apis = apis
               @logger = logger
 
-              @client = HTTP::Client.new(current_api, logger: logger)
+              @client = Remote::Transport::HTTP::Config::Client.new(current_api, logger: logger)
             end
 
             ##### there is only one transport! it's negotiation!

data/lib/datadog/core/remote/transport/http/config.rb

@@ -2,8 +2,7 @@
 
 require 'json'
 
-require_relative '../config'
-require_relative 'client'
+require_relative '../../../transport/http/client'
 require_relative '../../../utils/base64'
 require_relative '../../../utils/truncation'
 require_relative '../../../transport/http/response'
@@ -19,7 +18,6 @@ module Datadog
             # Response from HTTP transport for remote configuration
             class Response
               include Datadog::Core::Transport::HTTP::Response
-              include Core::Remote::Transport::Config::Response
 
               def initialize(http_response, options = {}) # standard:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
                 super(http_response)
@@ -114,6 +112,12 @@ module Datadog
                 end.freeze
               end
 
+              attr_reader :roots, :targets, :target_files, :client_configs
+
+              def empty?
+                @empty
+              end
+
               def inspect
                 "#{super}, #{
                   {
@@ -174,8 +178,8 @@ module Datadog
               end
             end
 
-            # Extensions for HTTP client
-            module Client
+            # Remote transport HTTP client
+            class Client < Core::Transport::HTTP::Client
               def send_config_payload(request)
                 send_request(request) do |api, env|
                   api.send_config(env)
@@ -240,10 +244,6 @@ module Datadog
                 end
               end
             end
-
-            # Add remote configuration behavior to transport components
-            ###### overrides send_payload! which calls send_<endpoint>! kills any other possible endpoint!
-            HTTP::Client.include(Config::Client)
           end
         end
       end

data/lib/datadog/core/remote/transport/http/negotiation.rb

@@ -2,8 +2,7 @@
 
 require 'json'
 
-require_relative '../negotiation'
-require_relative 'client'
+require_relative '../../../transport/http/client'
 require_relative '../../../transport/http/response'
 require_relative '../../../transport/http/api/endpoint'
 
@@ -17,7 +16,6 @@ module Datadog
             # Response from HTTP transport for agent feature negotiation
             class Response
               include Datadog::Core::Transport::HTTP::Response
-              include Core::Remote::Transport::Negotiation::Response
 
               def initialize(http_response, options = {})
                 super(http_response)
@@ -29,10 +27,24 @@ module Datadog
                 @config = options[:config]
                 @span_events = options[:span_events]
               end
+
+              # @!attribute [r] version
+              #   The version of the agent.
+              #   @return [String]
+              # @!attribute [r] endpoints
+              #   The HTTP endpoints the agent supports.
+              #   @return [Array<String>]
+              # @!attribute [r] config
+              #   The agent configuration. These are configured by the user when starting the agent, as well as any defaults.
+              #   @return [Hash]
+              # @!attribute [r] span_events
+              #   Whether the agent supports the top-level span events field in flushed spans.
+              #   @return [Boolean,nil]
+              attr_reader :version, :endpoints, :config, :span_events
             end
 
-            # Extensions for HTTP client
-            module Client
+            # Remote negotiation HTTP client
+            class Client < Core::Transport::HTTP::Client
               def send_info_payload(request)
                 send_request(request) do |api, env|
                   api.send_info(env)
@@ -92,9 +104,6 @@ module Datadog
                 end
               end
             end
-
-            # Add negotiation behavior to transport components
-            HTTP::Client.include(Negotiation::Client)
           end
         end
       end

data/lib/datadog/core/remote/transport/http.rb

@@ -4,6 +4,8 @@ require_relative '../../environment/container'
 require_relative '../../environment/ext'
 require_relative '../../transport/ext'
 require_relative '../../transport/http'
+require_relative 'config'
+require_relative 'negotiation'
 
 # TODO: Improve negotiation to allow per endpoint selection
 #

data/lib/datadog/core/remote/transport/negotiation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../../core/transport/request'
+require_relative 'http/negotiation'
 
 # TODO: Resolve conceptual conundrum
 #
@@ -30,23 +31,6 @@ module Datadog
           class Request < Datadog::Core::Transport::Request
           end
 
-          # Negotiation response
-          module Response
-            # @!attribute [r] version
-            #   The version of the agent.
-            #   @return [String]
-            # @!attribute [r] endpoints
-            #   The HTTP endpoints the agent supports.
-            #   @return [Array<String>]
-            # @!attribute [r] config
-            #   The agent configuration. These are configured by the user when starting the agent, as well as any defaults.
-            #   @return [Hash]
-            # @!attribute [r] span_events
-            #   Whether the agent supports the top-level span events field in flushed spans.
-            #   @return [Boolean,nil]
-            attr_reader :version, :endpoints, :config, :span_events
-          end
-
           # Negotiation transport
           class Transport
             attr_reader :client, :apis, :default_api, :current_api_id, :logger
@@ -55,7 +39,7 @@ module Datadog
               @apis = apis
               @logger = logger
 
-              @client = HTTP::Client.new(current_api, logger: logger)
+              @client = Remote::Transport::HTTP::Negotiation::Client.new(current_api, logger: logger)
             end
 
             def send_info

data/lib/datadog/core/remote/worker.rb

@@ -23,51 +23,47 @@ module Datadog
         attr_reader :logger
 
         def start
-          logger.debug { 'remote worker starting' }
+          logger.debug { "remote worker starting (pid: #{Process.pid})" }
 
-          acquire_lock
+          @mutex.synchronize do
+            if @stopped
+              logger.debug('remote worker: refusing to restart after previous stop')
+              return
+            end
 
-          if @stopped
-            logger.debug('remote worker: refusing to restart after previous stop')
-            return
-          end
-
-          return if @starting || @started
+            return if @starting || @started
 
-          @starting = true
+            @starting = true
 
-          thread = Thread.new { poll(@interval) }
-          thread.name = self.class.name
-          thread.thread_variable_set(:fork_safe, true)
-          @thr = thread
+            thread = Thread.new { poll(@interval) }
+            thread.name = self.class.name
+            thread.thread_variable_set(:fork_safe, true)
+            @thr = thread
 
-          @started = true
-          @starting = false
+            @started = true
+            @starting = false
+          end
 
           logger.debug { 'remote worker started' }
-        ensure
-          release_lock
         end
 
         def stop
-          logger.debug { 'remote worker stopping' }
+          logger.debug { "remote worker stopping (pid: #{Process.pid})" }
 
-          acquire_lock
+          @mutex.synchronize do
+            thread = @thr
 
-          thread = @thr
+            if thread
+              thread.kill
+              thread.join
+            end
 
-          if thread
-            thread.kill
-            thread.join
+            @started = false
+            @thr = nil
+            @stopped = true
           end
 
-          @started = false
-          @thr = nil
-          @stopped = true
-
           logger.debug { 'remote worker stopped' }
-        ensure
-          release_lock
         end
 
         def started?
@@ -76,14 +72,6 @@ module Datadog
 
         private
 
-        def acquire_lock
-          @mutex.lock
-        end
-
-        def release_lock
-          @mutex.unlock
-        end
-
         def poll(interval)
           loop do
             break unless @mutex.synchronize { @starting || @started }

data/lib/datadog/core/tag_builder.rb

@@ -8,10 +8,6 @@ module Datadog
   module Core
     # This module builds a hash of tags.
     #
-    # When changing or adding the tags, make sure they are kept in sync with
-    # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
-    # (Datadog internal link).
-    #
     # @api private
     module TagBuilder
       def self.fixed_environment_tags

data/lib/datadog/core/tag_normalizer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module Datadog
+  module Core
+    # @api private
+    module TagNormalizer
+      # Normalization logic used for tag keys and values that the Trace Agent has for traces
+      # Useful for ensuring that tag keys and values are normalized consistently
+      # An use case for now is Process Tags which need to be sent across various intakes (profiling, tracing, etc.) consistently
+
+      module_function
+
+      INVALID_TAG_CHARACTERS = %r{[^\p{L}0-9_\-:./]}
+      LEADING_INVALID_CHARS_NO_DIGITS = %r{\A[^\p{L}:]++}
+      LEADING_INVALID_CHARS_WITH_DIGITS = %r{\A[^\p{L}0-9:./]++}
+      MAX_BYTE_SIZE = 200 # Represents the general max tag length
+      MAX_PROCESS_VALUE_BYTE_SIZE = 100 # Represents the max tag length for process tags
+      VALID_ASCII_TAG = %r{\A[a-z:][a-z0-9:./-]*\z}
+
+      # Based on https://github.com/DataDog/datadog-agent/blob/45799c842bbd216bcda208737f9f11cade6fdd95/pkg/trace/traceutil/normalize.go#L131
+      # Specifically for general normalization:
+      # - Must be valid UTF-8
+      # - Invalid characters are replaced with an underscore
+      # - Leading non-letter characters are removed but colons are kept
+      # - Trailing non-letter characters are removed
+      # - Trailing underscores are removed
+      # - Consecutive underscores are merged into a single underscore
+      # - Maximum length is 200 characters
+      # If it's a tag value, allow it to start with a digit
+      # @param original_value [String] The original string
+      # @param remove_digit_start_char [Boolean] - whether to remove the leading digit (currently only used for tag values)
+      # @return [String] The normalized string
+      def self.normalize(original_value, remove_digit_start_char: false)
+        # DEV-3.0: Ideally this encode call should be replaced with Datadog::Core::Utils.utf8_encode once it
+        #          is safe to modify the default behavior.
+        value = original_value.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+        value.strip!
+        return "" if value.empty?
+
+        return value if value.bytesize <= MAX_BYTE_SIZE &&
+          value.match?(VALID_ASCII_TAG)
+
+        if value.bytesize > MAX_BYTE_SIZE
+          value = value.byteslice(0, MAX_BYTE_SIZE)
+          value.scrub!("")
+        end
+
+        value.downcase!
+        value.gsub!(INVALID_TAG_CHARACTERS, '_')
+
+        # The Trace Agent allows tag values to start with a number so this logic is here too
+        leading_invalid_regex = remove_digit_start_char ? LEADING_INVALID_CHARS_NO_DIGITS : LEADING_INVALID_CHARS_WITH_DIGITS
+        value.sub!(leading_invalid_regex, "")
+
+        value.squeeze!('_') if value.include?('__')
+        value.delete_suffix!('_')
+
+        value
+      end
+
+      # Process tags values follow an additional piece of normalization:
+      # - must not be more than 100 bytes
+      # - and must not contain colons
+      # @param value [String] The original string
+      # @return [String] The normalized string
+      def self.normalize_process_value(value)
+        value = normalize(value)
+        return value if value.empty?
+
+        value.tr!(':', '_')
+        value.squeeze!('_') if value.include?('__')
+
+        if value.bytesize > MAX_PROCESS_VALUE_BYTE_SIZE
+          value = value.byteslice(0, MAX_PROCESS_VALUE_BYTE_SIZE) || value
+          value.scrub!("")
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/component.rb

@@ -109,13 +109,17 @@ module Datadog
           @worker&.enabled = false
         end
 
-        def start(initial_event_is_change = false)
+        def start(initial_event_is_change = false, components:)
           return if !@enabled
 
           initial_event = if initial_event_is_change
-            Event::SynthAppClientConfigurationChange.new(agent_settings: @agent_settings)
+            Event::SynthAppClientConfigurationChange.new(
+              components: components,
+            )
           else
-            Event::AppStarted.new(agent_settings: @agent_settings)
+            Event::AppStarted.new(
+              components: components,
+            )
           end
 
           @worker.start(initial_event)