datadog 2.10.0 → 2.12.0

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module Datadog
+  module DI
+    module Transport
+      module HTTP
+        module Diagnostics
+          module Client
+            def send_diagnostics_payload(request)
+              send_request(request) do |api, env|
+                api.send_diagnostics(env)
+              end
+            end
+          end
+
+          module API
+            module Instance
+              def send_diagnostics(env)
+                raise DiagnosticsNotSupportedError, spec unless spec.is_a?(Diagnostics::API::Spec)
+
+                spec.send_diagnostics(env) do |request_env|
+                  call(request_env)
+                end
+              end
+
+              class DiagnosticsNotSupportedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'Diagnostics not supported for this API!'
+                end
+              end
+            end
+
+            module Spec
+              attr_accessor :diagnostics
+
+              def send_diagnostics(env, &block)
+                raise NoDiagnosticsEndpointDefinedError, self if diagnostics.nil?
+
+                diagnostics.call(env, &block)
+              end
+
+              class NoDiagnosticsEndpointDefinedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'No diagnostics endpoint is defined for API specification!'
+                end
+              end
+            end
+
+            # Endpoint for negotiation
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              attr_reader :encoder
+
+              def initialize(path, encoder)
+                super(:post, path)
+                @encoder = encoder
+              end
+
+              def call(env, &block)
+                event_payload = Core::Vendor::Multipart::Post::UploadIO.new(
+                  StringIO.new(env.request.parcel.data), 'application/json', 'event.json'
+                )
+                env.form = {'event' => event_payload}
+
+                super(env, &block)
+              end
+            end
+          end
+        end
+
+        HTTP::Client.include(Diagnostics::Client)
+      end
+    end
+  end
+end

data/lib/datadog/di/transport/http/input.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module Datadog
+  module DI
+    module Transport
+      module HTTP
+        module Input
+          module Client
+            def send_input_payload(request)
+              send_request(request) do |api, env|
+                api.send_input(env)
+              end
+            end
+          end
+
+          module API
+            module Instance
+              def send_input(env)
+                raise InputNotSupportedError, spec unless spec.is_a?(Input::API::Spec)
+
+                spec.send_input(env) do |request_env|
+                  call(request_env)
+                end
+              end
+
+              class InputNotSupportedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'Input not supported for this API!'
+                end
+              end
+            end
+
+            module Spec
+              attr_accessor :input
+
+              def send_input(env, &block)
+                raise NoInputEndpointDefinedError, self if input.nil?
+
+                input.call(env, &block)
+              end
+
+              class NoInputEndpointDefinedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'No input endpoint is defined for API specification!'
+                end
+              end
+            end
+
+            # Endpoint for negotiation
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              HEADER_CONTENT_TYPE = 'Content-Type'
+
+              attr_reader \
+                :encoder
+
+              def initialize(path, encoder)
+                super(:post, path)
+                @encoder = encoder
+              end
+
+              def call(env, &block)
+                # Encode body & type
+                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                env.body = env.request.parcel.data
+
+                super(env, &block)
+              end
+            end
+          end
+        end
+
+        HTTP::Client.include(Input::Client)
+      end
+    end
+  end
+end

data/lib/datadog/di/transport/http.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../core/environment/container'
+require_relative '../../core/environment/ext'
+require_relative '../../core/transport/ext'
+require_relative '../../core/transport/http/adapters/net'
+require_relative '../../core/transport/http/adapters/test'
+require_relative '../../core/transport/http/adapters/unix_socket'
+require_relative 'diagnostics'
+require_relative 'input'
+require_relative 'http/api'
+require_relative '../../core/transport/http/builder'
+require_relative '../../../datadog/version'
+
+module Datadog
+  module DI
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        module_function
+
+        # Builds a new Transport::HTTP::Client
+        def new(klass, &block)
+          Core::Transport::HTTP::Builder.new(
+            api_instance_class: API::Instance, &block
+          ).to_transport(klass)
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def diagnostics(
+          agent_settings:,
+          **options
+        )
+          new(DI::Transport::Diagnostics::Transport) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::DIAGNOSTICS, apis[API::DIAGNOSTICS]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def input(
+          agent_settings:,
+          **options
+        )
+          new(DI::Transport::Input::Transport) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::INPUT, apis[API::INPUT]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR => Core::Environment::Ext::LANG_ENGINE,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+            # Pretend that stats computation are already done by the client
+            if Datadog.configuration.appsec.standalone.enabled
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
+          end
+        end
+
+        def default_adapter
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        end
+
+        # Add adapters to registry
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::Net,
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        )
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
+          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+        )
+      end
+    end
+  end
+end

data/lib/datadog/di/transport/input.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../core/transport/parcel'
+require_relative 'http/client'
+
+module Datadog
+  module DI
+    module Transport
+      module Input
+        class EncodedParcel
+          include Datadog::Core::Transport::Parcel
+        end
+
+        class Request < Datadog::Core::Transport::Request
+        end
+
+        class Transport
+          attr_reader :client, :apis, :default_api, :current_api_id
+
+          def initialize(apis, default_api)
+            @apis = apis
+
+            @client = HTTP::Client.new(current_api)
+          end
+
+          def current_api
+            @apis[HTTP::API::INPUT]
+          end
+
+          def send_input(payload)
+            json = JSON.dump(payload)
+            parcel = EncodedParcel.new(json)
+            request = Request.new(parcel)
+
+            response = @client.send_input_payload(request)
+            unless response.ok?
+              # TODO Datadog::Core::Transport::InternalErrorResponse
+              # does not have +code+ method, what is the actual API of
+              # these response objects?
+              raise Error::AgentCommunicationError, "send_input failed: #{begin
+                response.code
+              rescue
+                "???"
+              end}: #{response.payload}"
+            end
+          rescue Error::AgentCommunicationError
+            raise
+          # Datadog::Core::Transport does not perform any exception mapping,
+          # therefore we could have any exception here from failure to parse
+          # agent URI for example.
+          # If we ever implement retries for network errors, we should distinguish
+          # actual network errors from non-network errors that are raised by
+          # transport code.
+          rescue => exc
+            raise Error::AgentCommunicationError, "send_input failed: #{exc.class}: #{exc}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/utils.rb

@@ -3,6 +3,82 @@
 module Datadog
   module DI
     module Utils
+      # General path matching considerations
+      # ------------------------------------
+      #
+      # The following use cases must be supported:
+      # 1. The "probe path" is relative path to the file from source code
+      #    repository root. The project is deployed from the repository root,
+      #    such that that same relative path exists at runtime from the
+      #    root of the application.
+      # 2. The "probe path" is a relative path to the file in a monorepo
+      #    where the project being deployed is in a subdirectory.
+      #    This the "probe path" contains additional directory components
+      #    in the beginning that do not exist in the runtime environment.
+      # 3. The "probe path" is an absolute path to the file on the customer's
+      #    development system. As specified this path definitely does not
+      #    exist at runtime, and can start with a prefix that is unknown
+      #    to any both UI and tracer code.
+      # 4. Same as (3), but the customer is using a Windows computer for
+      #    development and has the path specified in the wrong case
+      #    (which works fine on their development machine).
+      # 5. The "probe path" is the basename or any suffix of the path to
+      #    the desired file, typed manually by the customer into the UI.
+      #
+      # A related concern is that if multiple runtime paths match the path
+      # specification in the probe, the tracer must return an error to the
+      # backend/UI rather than instrumenting any of the matching paths.
+      #
+      # The logic for path matching should therefore, generally, be as follows:
+      # 1. If the "probe path" is absolute, see if it exists at runtime.
+      #    If so, take it as the desired path and finish.
+      # 2. Attempt to identify the application root, by checking if the current
+      #    working directory contains a file called Gemfile. If yes, assume
+      #    the current working directory is the application root, otherwise
+      #    consider the application root to be unknown.
+      # 3. If the application root is known and the "probe path" is relative,
+      #    concatenate the "probe path" to the application root and check
+      #    if the resulting path exists at runtime. If so, take it as the
+      #    desired path and finish.
+      # 4. If the "probe path" is relative, go through the known file paths,
+      #    filter these paths down to those whose suffix is the "probe path",
+      #    and check how many we are left with. If exactly one, assume this
+      #    is the desired path and finish. If more than one, return an error
+      #    "multiple matching paths".
+      # 5. If the application root is known, for each suffix of the "probe path",
+      #    see if that relative paths concatenated to the application root
+      #    results in a known file. If a known file is found, assume this
+      #    is the wanted file and finish.
+      # 6. For each suffix of the "probe path", filter the set of known paths
+      #    down to those that end in the suffix. If exactly one path remains
+      #    for a given suffix, assume this is the wanted path and finish.
+      #    If more than one path remains for a given suffix, return the error
+      #    "multiple matching paths".
+      # 7. Repeat step 5 but perform case-insensitive comparison.
+      # 8. Repeat step 6 but perform case-insensitive comparison.
+      #
+      # Note that we do not look for "probe paths" under the current working
+      # directory at runtime if the current working directory does not contain
+      # a Gemfile, to avoid finding files from potentially undesired bases.
+      #
+      # What "known file"/"known path" means also differs based on the
+      # operation being performed:
+      # - If the operation is "install a probe", "known file/path" can
+      #   include files on the filesystem that have not been loaded as
+      #   well as paths from the code tracker.
+      # - If the operation is "check if any pending probes match the file
+      #   that was just loaded", we would only consider the path that was
+      #   just loaded and not check the filesystem.
+      #
+      # Filesystem inquiries are obviously quite expensive and should be
+      # cached. For the vast majority of applications it should be safe to
+      # indefinitely cache whether a particular filesystem paths exists
+      # in both positive and negative.
+      #
+      # As a "quick fix", currently after performing the suffix matching
+      # we just strip leading directory components from the "probe path"
+      # until we get a match via a "suffix of the suffix".
+
       # Returns whether the provided +path+ matches the user-designated
       # file suffix (of a line probe).
       #
@@ -41,6 +117,21 @@ module Datadog
           # !!(path =~ %r,(/|\A)#{Regexp.quote(suffix)}\z,)
         end
       end
+
+      # Returns whether the provided +path+ matches the "probe path" in
+      # +spec+. Attempts all of the fuzzy matches by stripping directories
+      # from the front of +spec+. Does not consider othr known paths to
+      # identify the case of (potentially) multiple matching paths for +spec+.
+      module_function def path_can_match_spec?(path, spec)
+        return true if path_matches_suffix?(path, spec)
+
+        spec = spec.dup
+        loop do
+          return false unless spec.include?('/')
+          spec.sub!(%r{.*/+}, '')
+          return true if path_matches_suffix?(path, spec)
+        end
+      end
     end
   end
 end

data/lib/datadog/di.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'di/logger'
 require_relative 'di/base'
 require_relative 'di/error'
 require_relative 'di/code_tracker'
@@ -15,7 +16,8 @@ require_relative 'di/probe_notifier_worker'
 require_relative 'di/redactor'
 require_relative 'di/remote'
 require_relative 'di/serializer'
-require_relative 'di/transport'
+#require_relative 'di/transport'
+require_relative 'di/transport/http'
 require_relative 'di/utils'
 
 module Datadog
@@ -58,6 +60,8 @@ if %w(1 true).include?(ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED']) # steep:ignore
   #
   # If DI is enabled programmatically, the application can (and must,
   # for line probes to work) activate tracking in an initializer.
+  # We seem to have Datadog.logger here already
+  Datadog.logger.debug("di: activating code tracking")
   Datadog::DI.activate_tracking
 end
 

data/lib/datadog/profiling/component.rb

@@ -435,17 +435,11 @@ module Datadog
       end
 
       private_class_method def self.enable_gvl_profiling?(settings, logger)
-        if RUBY_VERSION < "3.2"
-          if settings.profiling.advanced.preview_gvl_enabled
-            logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
-          end
-
-          return false
-        end
+        return false if RUBY_VERSION < "3.2"
 
         # GVL profiling only makes sense in the context of timeline. We could emit a warning here, but not sure how
         # useful it is -- if a customer disables timeline, there's nowhere to look for GVL profiling anyway!
-        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.preview_gvl_enabled
+        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.gvl_enabled
       end
     end
   end

data/lib/datadog/profiling/load_native_extension.rb

@@ -1,41 +1,9 @@
 # frozen_string_literal: true
 
-# This file is used to load the profiling native extension. It works in two steps:
-#
-# 1. Load the datadog_profiling_loader extension. This extension will be used to load the actual extension, but in
-#    a special way that avoids exposing native-level code symbols. See `datadog_profiling_loader.c` for more details.
-#
-# 2. Use the Datadog::Profiling::Loader exposed by the datadog_profiling_loader extension to load the actual
-#    profiling native extension.
-#
-# All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
-# the first time it gets required, to avoid any issues with the native extension being initialized more than once.
-
 begin
-  require "datadog_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+  require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
     "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
     "(Details: #{e.message})"
 end
-
-extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-file_name = "#{extension_name}.#{RbConfig::CONFIG["DLEXT"]}"
-full_file_path = "#{__dir__}/../../#{file_name}"
-
-unless File.exist?(full_file_path)
-  extension_dir = Gem.loaded_specs["datadog"].extension_dir
-  candidate_path = "#{extension_dir}/#{file_name}"
-  if File.exist?(candidate_path)
-    full_file_path = candidate_path
-  else
-    # We found none of the files. This is unexpected. Let's go ahead anyway, the error is going to be reported further
-    # down anyway.
-  end
-end
-
-init_function_name = "Init_#{extension_name.split(".").first}"
-
-status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
-
-raise "Failure to load #{extension_name} due to #{result}" if status == :error

data/lib/datadog/tracing/component.rb

@@ -49,6 +49,7 @@ module Datadog
         Tracing::Tracer.new(
           default_service: settings.service,
           enabled: settings.tracing.enabled,
+          logger: logger,
           trace_flush: trace_flush,
           sampler: sampler_delegator,
           span_sampler: build_span_sampler(settings),

data/lib/datadog/tracing/configuration/ext.rb

@@ -16,6 +16,7 @@ module Datadog
         # @public_api
         module SpanAttributeSchema
           ENV_GLOBAL_DEFAULT_SERVICE_NAME_ENABLED = 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED'
+          ENV_PEER_SERVICE_DEFAULTS_ENABLED = 'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED'
           ENV_PEER_SERVICE_MAPPING = 'DD_TRACE_PEER_SERVICE_MAPPING'
         end
 

data/lib/datadog/tracing/contrib/extensions.rb

@@ -130,6 +130,20 @@ module Datadog
                     o.default({})
                   end
 
+                  # Enables population of default in the `peer.service` span tag.
+                  # Explicitly setting the `peer.service` for an integration will
+                  # still be honored with this option disabled.
+                  #
+                  # Also when disabled, other peer service related configurations have no effect.
+                  #
+                  # @default `DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED` environment variable, otherwise `false`
+                  # @return [Boolean]
+                  option :peer_service_defaults do |o|
+                    o.env Tracing::Configuration::Ext::SpanAttributeSchema::ENV_PEER_SERVICE_DEFAULTS_ENABLED
+                    o.type :bool
+                    o.default false
+                  end
+
                   # Global service name behavior
                   settings :global_default_service_name do
                     # Overrides default service name to global service name

data/lib/datadog/tracing/contrib/graphql/configuration/error_extension_env_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GraphQL
+        module Configuration
+          # Parses the environment variable `DD_TRACE_GRAPHQL_ERROR_EXTENSIONS` for error extension names declaration.
+          class ErrorExtensionEnvParser
+            # Parses the environment variable `DD_TRACE_GRAPHQL_ERROR_EXTENSIONS` into an array of error extension names.
+            def self.call(values)
+              # Split by comma, remove leading and trailing whitespaces,
+              # remove empty values, and remove repeated values.
+              values.split(',').each(&:strip!).reject(&:empty?).uniq
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/graphql/configuration/settings.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../configuration/settings'
 require_relative '../ext'
+require_relative 'error_extension_env_parser'
 
 module Datadog
   module Tracing
@@ -44,9 +45,19 @@ module Datadog
             end
 
             option :with_unified_tracer do |o|
+              o.env Ext::ENV_WITH_UNIFIED_TRACER
               o.type :bool
               o.default false
             end
+
+            # Capture error extensions provided by the user in their GraphQL error responses.
+            # The extensions can be anything, so the user is responsible for ensuring they are safe to capture.
+            option :error_extensions do |o|
+              o.env Ext::ENV_ERROR_EXTENSIONS
+              o.type :array, nilable: false
+              o.default []
+              o.env_parser { |v| ErrorExtensionEnvParser.call(v) }
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/graphql/ext.rb

@@ -11,8 +11,13 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPHQL_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
+          ENV_WITH_UNIFIED_TRACER = 'DD_TRACE_GRAPHQL_WITH_UNIFIED_TRACER'
+          ENV_ERROR_EXTENSIONS = 'DD_TRACE_GRAPHQL_ERROR_EXTENSIONS'
           SERVICE_NAME = 'graphql'
           TAG_COMPONENT = 'graphql'
+
+          # Span event name for query-level errors
+          EVENT_QUERY_ERROR = 'dd.graphql.query.error'
         end
       end
     end