ddtrace 0.42.0 → 0.54.2

data/lib/ddtrace/profiling/tasks/setup.rb

@@ -0,0 +1,90 @@
+# typed: false
+require 'ddtrace/utils/only_once'
+require 'ddtrace/profiling'
+require 'ddtrace/profiling/ext/forking'
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
+      class Setup
+        ACTIVATE_EXTENSIONS_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
+        def run
+          ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
+            begin
+              check_if_cpu_time_profiling_is_supported
+              activate_forking_extensions
+              setup_at_fork_hooks
+            rescue StandardError, ScriptError => e
+              Datadog.logger.warn do
+                "Profiler extensions unavailable. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+              end
+            end
+          end
+        end
+
+        private
+
+        def activate_forking_extensions
+          if Ext::Forking.supported?
+            Ext::Forking.apply!
+          elsif Datadog.configuration.profiling.enabled
+            Datadog.logger.debug('Profiler forking extensions skipped; forking not supported.')
+          end
+        rescue StandardError, ScriptError => e
+          Datadog.logger.warn do
+            "Profiler forking extensions unavailable. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+          end
+        end
+
+        def check_if_cpu_time_profiling_is_supported
+          unsupported = cpu_time_profiling_unsupported_reason
+
+          if unsupported
+            Datadog.logger.info do
+              'CPU time profiling skipped because native CPU time is not supported: ' \
+              "#{unsupported}. Profiles containing 'Wall time' data will still be reported."
+            end
+          end
+        end
+
+        def setup_at_fork_hooks
+          if Process.respond_to?(:at_fork)
+            Process.at_fork(:child) do
+              begin
+                # When Ruby forks, clock IDs for each of the threads
+                # will change. We can only update these IDs from the
+                # execution context of the thread that owns it.
+                # This hook will update the IDs for the main thread
+                # after a fork occurs.
+                Thread.current.send(:update_native_ids) if Thread.current.respond_to?(:update_native_ids, true)
+
+                # Restart profiler, if enabled
+                Datadog.profiler.start if Datadog.profiler
+              rescue StandardError => e
+                Datadog.logger.warn do
+                  "Error during post-fork hooks. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+                end
+              end
+            end
+          end
+        end
+
+        def cpu_time_profiling_unsupported_reason
+          # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons
+
+          if RUBY_ENGINE == 'jruby'
+            'JRuby is not supported'
+          elsif RUBY_PLATFORM.include?('darwin')
+            'Feature requires Linux; macOS is not supported'
+          elsif RUBY_PLATFORM =~ /(mswin|mingw)/
+            'Feature requires Linux; Windows is not supported'
+          elsif !RUBY_PLATFORM.include?('linux')
+            "Feature requires Linux; #{RUBY_PLATFORM} is not supported"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/trace_identifiers/ddtrace.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Profiling
+    module TraceIdentifiers
+      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (root span id and span id)
+      # for a given thread, if there is an active trace for that thread in the supplied tracer object.
+      class Ddtrace
+        def initialize(tracer:)
+          @tracer = (tracer if tracer.respond_to?(:call_context))
+        end
+
+        def trace_identifiers_for(thread)
+          return unless @tracer
+
+          context = @tracer.call_context(thread)
+          return unless context
+
+          span, root_span = context.current_span_and_root_span
+          return unless span && root_span
+
+          root_span_id = root_span.span_id || 0
+          span_id = span.span_id || 0
+
+          [root_span_id, span_id, maybe_extract_resource(root_span)] if root_span_id != 0 && span_id != 0
+        end
+
+        private
+
+        # NOTE: Currently we're only interested in HTTP service endpoints. Over time, this list may be expanded.
+        # Resources MUST NOT include personal identifiable information (PII); this should not be the case with
+        # ddtrace integrations, but worth mentioning just in case :)
+        def maybe_extract_resource(root_span)
+          root_span.resource if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/trace_identifiers/helper.rb

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'ddtrace/profiling/trace_identifiers/ddtrace'
+
+module Datadog
+  module Profiling
+    module TraceIdentifiers
+      # Helper used to retrieve the trace identifiers (root span id and span id) for a given thread,
+      # if there is an active trace for that thread for the supported tracing APIs.
+      #
+      # This data is used to connect profiles to the traces -- samples in a profile will be tagged with this data and
+      # the profile can be filtered down to look at only the samples for a given trace.
+      class Helper
+        DEFAULT_SUPPORTED_APIS = [
+          ::Datadog::Profiling::TraceIdentifiers::Ddtrace
+        ].freeze
+        private_constant :DEFAULT_SUPPORTED_APIS
+
+        def initialize(
+          tracer:,
+          # If this is disabled, the helper will strip the optional trace_resource_container even if provided by the api
+          endpoint_collection_enabled:,
+          supported_apis: DEFAULT_SUPPORTED_APIS.map { |api| api.new(tracer: tracer) }
+        )
+          @endpoint_collection_enabled = endpoint_collection_enabled
+          @supported_apis = supported_apis
+        end
+
+        # Expected output of the #trace_identifiers_for
+        # duck type is [root_span_id, span_id, (optional trace_resource_container)]
+        def trace_identifiers_for(thread)
+          @supported_apis.each do |api|
+            trace_identifiers = api.trace_identifiers_for(thread)
+
+            if trace_identifiers
+              return @endpoint_collection_enabled ? trace_identifiers : trace_identifiers[0..1]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/client.rb

@@ -0,0 +1,15 @@
+# typed: true
+module Datadog
+  module Profiling
+    module Transport
+      # Generic interface for profiling transports
+      module Client
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        def send_profiling_flush(flush)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/api/endpoint.rb

@@ -0,0 +1,94 @@
+# typed: true
+require 'ddtrace/ext/profiling'
+require 'ddtrace/utils/compression'
+require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
+
+require 'ddtrace/transport/http/api/endpoint'
+require 'ddtrace/profiling/transport/http/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        module API
+          # Datadog API endpoint for profiling
+          class Endpoint < Datadog::Transport::HTTP::API::Endpoint
+            include Datadog::Ext::Profiling::Transport::HTTP
+
+            # These tags are read from the flush object (see below) directly and so we ignore any extra copies that
+            # may come in the tags hash to avoid duplicates.
+            TAGS_TO_IGNORE_IN_TAGS_HASH = %w[service env version].freeze
+            private_constant :TAGS_TO_IGNORE_IN_TAGS_HASH
+
+            attr_reader \
+              :encoder
+
+            def initialize(path, encoder)
+              super(:post, path)
+              @encoder = encoder
+            end
+
+            def call(env, &block)
+              # Build request
+              env.form = build_form(env)
+
+              # Send request
+              http_response = super(env, &block)
+
+              # Build response
+              Profiling::Transport::HTTP::Response.new(http_response)
+            end
+
+            def build_form(env)
+              flush = env.request.parcel.data
+              pprof_file = build_pprof(flush)
+
+              form = {
+                FORM_FIELD_INTAKE_VERSION => '3', # Aka 1.3 intake format
+                FORM_FIELD_RECORDING_START => flush.start.utc.iso8601,
+                FORM_FIELD_RECORDING_END => flush.finish.utc.iso8601,
+                FORM_FIELD_TAGS => [
+                  "#{FORM_FIELD_TAG_RUNTIME}:#{flush.language}",
+                  "#{FORM_FIELD_TAG_RUNTIME_ID}:#{flush.runtime_id}",
+                  "#{FORM_FIELD_TAG_RUNTIME_ENGINE}:#{flush.runtime_engine}",
+                  "#{FORM_FIELD_TAG_RUNTIME_PLATFORM}:#{flush.runtime_platform}",
+                  "#{FORM_FIELD_TAG_RUNTIME_VERSION}:#{flush.runtime_version}",
+                  "#{FORM_FIELD_TAG_PID}:#{Process.pid}",
+                  "#{FORM_FIELD_TAG_PROFILER_VERSION}:#{flush.profiler_version}",
+                  # NOTE: Redundant w/ 'runtime'; may want to remove this later.
+                  "#{FORM_FIELD_TAG_LANGUAGE}:#{flush.language}",
+                  "#{FORM_FIELD_TAG_HOST}:#{flush.host}",
+                  *flush
+                    .tags
+                    .reject { |tag_key| TAGS_TO_IGNORE_IN_TAGS_HASH.include?(tag_key) }
+                    .map { |tag_key, tag_value| "#{tag_key}:#{tag_value}" }
+                ],
+                FORM_FIELD_PPROF_DATA => pprof_file,
+                FORM_FIELD_FAMILY => flush.language,
+              }
+
+              # Optional fields
+              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_SERVICE}:#{flush.service}" unless flush.service.nil?
+              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_ENV}:#{flush.env}" unless flush.env.nil?
+              form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_VERSION}:#{flush.version}" unless flush.version.nil?
+
+              form
+            end
+
+            def build_pprof(flush)
+              pprof = encoder.encode(flush)
+
+              gzipped_pprof_data = Datadog::Utils::Compression.gzip(pprof.data)
+
+              Datadog::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_pprof_data),
+                HEADER_CONTENT_TYPE_OCTET_STREAM,
+                PPROF_DEFAULT_FILENAME
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/api/instance.rb

@@ -0,0 +1,37 @@
+# typed: true
+require 'ddtrace/transport/http/api/instance'
+require 'ddtrace/profiling/transport/http/api/spec'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        module API
+          # API instance for profiling
+          class Instance < Datadog::Transport::HTTP::API::Instance
+            def send_profiling_flush(env)
+              raise ProfilesNotSupportedError, spec unless spec.is_a?(Spec)
+
+              spec.send_profiling_flush(env) do |request_env|
+                call(request_env)
+              end
+            end
+
+            # Raised when profiles sent to API that does not support profiles
+            class ProfilesNotSupportedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'Profiles not supported for this API!'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/api/spec.rb

@@ -0,0 +1,41 @@
+# typed: true
+require 'ddtrace/transport/http/api/spec'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        module API
+          # API specification for profiling
+          class Spec < Datadog::Transport::HTTP::API::Spec
+            attr_accessor \
+              :profiles
+
+            def send_profiling_flush(env, &block)
+              raise NoProfilesEndpointDefinedError, self if profiles.nil?
+
+              profiles.call(env, &block)
+            end
+
+            def encoder
+              profiles.encoder
+            end
+
+            # Raised when profiles sent but no profiles endpoint is defined
+            class NoProfilesEndpointDefinedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'No profiles endpoint is defined for API specification!'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/api.rb

@@ -0,0 +1,44 @@
+# typed: true
+require 'ddtrace/transport/http/api/map'
+require 'ddtrace/profiling/encoding/profile'
+require 'ddtrace/profiling/transport/http/api/spec'
+require 'ddtrace/profiling/transport/http/api/instance'
+require 'ddtrace/profiling/transport/http/api/endpoint'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        # Extensions for HTTP API Spec
+        module API
+          # Default API versions
+          V1 = 'v1'.freeze
+
+          module_function
+
+          def agent_defaults
+            @agent_defaults ||= Datadog::Transport::HTTP::API::Map[
+              V1 => Spec.new do |s|
+                s.profiles = Endpoint.new(
+                  '/profiling/v1/input'.freeze,
+                  Profiling::Encoding::Profile::Protobuf
+                )
+              end
+            ]
+          end
+
+          def api_defaults
+            @api_defaults ||= Datadog::Transport::HTTP::API::Map[
+              V1 => Spec.new do |s|
+                s.profiles = Endpoint.new(
+                  '/v1/input'.freeze,
+                  Profiling::Encoding::Profile::Protobuf
+                )
+              end
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/builder.rb

@@ -0,0 +1,29 @@
+# typed: true
+require 'ddtrace/transport/http/builder'
+
+require 'ddtrace/profiling/transport/http/api'
+require 'ddtrace/profiling/transport/http/client'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        # Builds new instances of Transport::HTTP::Client
+        class Builder < Datadog::Transport::HTTP::Builder
+          def api_instance_class
+            API::Instance
+          end
+
+          def to_transport
+            raise Datadog::Transport::HTTP::Builder::NoDefaultApiError if @default_api.nil?
+
+            # TODO: Profiling doesn't have multiple APIs yet.
+            #       When it does, we should build it out with these APIs.
+            #       Just use :default_api for now.
+            Client.new(to_api_instances[@default_api])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/client.rb

@@ -0,0 +1,34 @@
+# typed: true
+require 'ddtrace/transport/http/client'
+require 'ddtrace/profiling/transport/client'
+
+module Datadog
+  module Profiling
+    module Transport
+      module HTTP
+        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+        class Client < Datadog::Transport::HTTP::Client
+          include Transport::Client
+
+          def send_profiling_flush(flush)
+            # Build a request
+            request = Profiling::Transport::Request.new(flush)
+            send_payload(request).tap do |response|
+              if response.ok?
+                Datadog.logger.debug('Successfully reported profiling data')
+              else
+                Datadog.logger.debug { "Failed to report profiling data -- #{response.inspect}" }
+              end
+            end
+          end
+
+          def send_payload(request)
+            send_request(request) do |api, env|
+              api.send_profiling_flush(env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http/response.rb

@@ -0,0 +1,22 @@
+# typed: true
+require 'ddtrace/transport/http/response'
+require 'ddtrace/profiling/transport/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      # HTTP transport behavior for profiling
+      module HTTP
+        # Response from HTTP transport for profiling
+        class Response
+          include Datadog::Transport::HTTP::Response
+          include Profiling::Transport::Response
+
+          def initialize(http_response, options = {})
+            super(http_response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/http.rb

@@ -0,0 +1,111 @@
+# typed: true
+require 'datadog/core/environment/ext'
+require 'ddtrace/ext/transport'
+
+require 'datadog/core/environment/container'
+require 'datadog/core/environment/variable_helpers'
+
+require 'ddtrace/profiling/transport/http/builder'
+require 'ddtrace/profiling/transport/http/api'
+
+require 'ddtrace/transport/http/adapters/net'
+require 'ddtrace/transport/http/adapters/test'
+require 'ddtrace/transport/http/adapters/unix_socket'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        # Builds a new Transport::HTTP::Client
+        def self.new(&block)
+          Builder.new(&block).to_transport
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        def self.default(
+          profiling_upload_timeout_seconds:,
+          agent_settings:,
+          site: nil,
+          api_key: nil,
+          agentless_allowed: agentless_allowed?
+        )
+          new do |transport|
+            transport.headers default_headers
+
+            # Configure adapter & API
+            if site && api_key && agentless_allowed
+              configure_for_agentless(
+                transport,
+                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
+                site: site,
+                api_key: api_key
+              )
+            else
+              configure_for_agent(
+                transport,
+                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
+                agent_settings: agent_settings
+              )
+            end
+          end
+        end
+
+        def self.default_headers
+          {
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
+          apis = API.agent_defaults
+
+          transport.adapter(agent_settings.merge(timeout_seconds: profiling_upload_timeout_seconds))
+          transport.api(API::V1, apis[API::V1], default: true)
+
+          # NOTE: This proc, when it exists, usually overrides the transport specified above
+          if agent_settings.deprecated_for_removal_transport_configuration_proc
+            agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+          end
+        end
+
+        private_class_method def self.configure_for_agentless(transport, profiling_upload_timeout_seconds:, site:, api_key:)
+          apis = API.api_defaults
+
+          site_uri = URI(format(Datadog::Ext::Profiling::Transport::HTTP::URI_TEMPLATE_DD_API, site))
+          hostname = site_uri.host
+          port = site_uri.port
+
+          transport.adapter(
+            Datadog::Ext::Transport::HTTP::ADAPTER,
+            hostname,
+            port,
+            timeout: profiling_upload_timeout_seconds,
+            ssl: site_uri.scheme == 'https'
+          )
+          transport.api(API::V1, apis[API::V1], default: true)
+          transport.headers(Datadog::Ext::Transport::HTTP::HEADER_DD_API_KEY => api_key)
+        end
+
+        private_class_method def self.agentless_allowed?
+          Datadog::Core::Environment::VariableHelpers.env_to_bool(Datadog::Ext::Profiling::ENV_AGENTLESS, false)
+        end
+
+        # Add adapters to registry
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net,
+                                                        Datadog::Ext::Transport::HTTP::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test,
+                                                        Datadog::Ext::Transport::Test::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket,
+                                                        Datadog::Ext::Transport::UnixSocket::ADAPTER)
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/io/client.rb

@@ -0,0 +1,28 @@
+# typed: true
+require 'ddtrace/transport/io/client'
+require 'ddtrace/profiling/transport/client'
+require 'ddtrace/profiling/transport/request'
+require 'ddtrace/profiling/transport/io/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      module IO
+        # IO transport for profiling
+        class Client < Datadog::Transport::IO::Client
+          include Transport::Client
+
+          def send_profiling_flush(flush)
+            # Build a request
+            request = Profiling::Transport::Request.new(flush)
+            send_request(request)
+          end
+
+          def build_response(_request, _data, result)
+            Profiling::Transport::IO::Response.new(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/io/response.rb

@@ -0,0 +1,17 @@
+# typed: strict
+require 'ddtrace/transport/io/response'
+require 'ddtrace/profiling/transport/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      # IO transport behavior for profiling
+      module IO
+        # Response from IO transport for profiling
+        class Response < Datadog::Transport::IO::Response
+          include Profiling::Transport::Response
+        end
+      end
+    end
+  end
+end