ddtrace 0.52.0 → 1.8.0

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

@@ -1,37 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,120 +0,0 @@
-# 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.default_adapter
-          :net_http
-        end
-
-        private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
-          apis = API.agent_defaults
-
-          transport.adapter(
-            default_adapter,
-            agent_settings.hostname,
-            agent_settings.port,
-            # We explictly use profiling_upload_timeout_seconds instead of agent_settings.timeout because profile
-            # uploads are bigger and thus we employ a separate configuration.
-            timeout: profiling_upload_timeout_seconds,
-            ssl: agent_settings.ssl
-          )
-          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(
-            default_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, :net_http)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, :test)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, :unix)
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

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

@@ -1,31 +0,0 @@
-# typed: true
-require 'ddtrace/profiling/transport/io/client'
-require 'ddtrace/profiling/encoding/profile'
-
-module Datadog
-  module Profiling
-    module Transport
-      # Namespace for profiling IO transport components
-      module IO
-        module_function
-
-        # Builds a new Profiling::Transport::IO::Client
-        def new(out, encoder, options = {})
-          Client.new(out, encoder, options)
-        end
-
-        # Builds a new Profiling::Transport::IO::Client with default settings
-        # Pass options to override any settings.
-        def default(options = {})
-          options = options.dup
-
-          new(
-            options.delete(:out) || $stdout,
-            options.delete(:encoder) || Profiling::Encoding::Profile::Protobuf,
-            options
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# typed: true
-require 'ddtrace/transport/parcel'
-
-module Datadog
-  module Profiling
-    module Transport
-      # Data transfer object for profiling data
-      class Parcel
-        include Datadog::Transport::Parcel
-
-        def encode_with(encoder)
-          # TODO: Determine encoding behavior
-          encoder.encode(data)
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# typed: true
-require 'ddtrace/transport/request'
-require 'ddtrace/profiling/transport/parcel'
-
-module Datadog
-  module Profiling
-    module Transport
-      # Profiling request
-      class Request < Datadog::Transport::Request
-        def initialize(flush)
-          super(Parcel.new(flush))
-        end
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-# typed: strict
-module Datadog
-  module Profiling
-    module Transport
-      # Profiling response
-      module Response; end
-    end
-  end
-end

data/lib/ddtrace/profiling.rb

@@ -1,151 +0,0 @@
-# typed: true
-require 'datadog/core/environment/variable_helpers'
-require 'ddtrace/utils/only_once'
-
-module Datadog
-  # Contains profiler for generating stack profiles, etc.
-  module Profiling # rubocop:disable Metrics/ModuleLength
-    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
-    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
-
-    SKIPPED_NATIVE_EXTENSION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :SKIPPED_NATIVE_EXTENSION_ONLY_ONCE
-
-    def self.supported?
-      unsupported_reason.nil?
-    end
-
-    def self.unsupported_reason
-      # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons -- e.g. tell users
-      # first that they can't use this on JRuby before telling them that they are missing protobuf
-
-      ruby_engine_unsupported? ||
-        native_library_failed_to_load? ||
-        protobuf_gem_unavailable? ||
-        protobuf_version_unsupported? ||
-        protobuf_failed_to_load?
-    end
-
-    private_class_method def self.ruby_engine_unsupported?
-      'JRuby is not supported' if RUBY_ENGINE == 'jruby'
-    end
-
-    private_class_method def self.protobuf_gem_unavailable?
-      # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
-      # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
-      # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
-      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].nil?
-        "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_version_unsupported?
-      # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
-      # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
-      # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
-      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
-        'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
-        "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_failed_to_load?
-      unless protobuf_loaded_successfully?
-        'There was an error loading the google-protobuf library; see previous warning message for details'
-      end
-    end
-
-    # The `google-protobuf` gem depends on a native component, and its creators helpfully tried to provide precompiled
-    # versions of this extension on rubygems.org.
-    #
-    # Unfortunately, for a long time, the supported Ruby versions metadata on these precompiled versions of the extension
-    # was not correctly set. (This is fixed in newer versions -- but not all Ruby versions we want to support can use
-    # these.)
-    #
-    # Thus, the gem can still be installed, but can be in a broken state. To avoid breaking customer applications, we
-    # use this helper to load it and gracefully handle failures.
-    private_class_method def self.protobuf_loaded_successfully?
-      return @protobuf_loaded if defined?(@protobuf_loaded)
-
-      begin
-        require 'google/protobuf'
-        @protobuf_loaded = true
-      rescue LoadError => e
-        # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
-        # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
-        Kernel.warn(
-          '[DDTRACE] Error while loading google-protobuf gem. ' \
-          "Cause: '#{e.message}' Location: '#{Array(e.backtrace).first}'. " \
-          'This can happen when google-protobuf is missing its native components. ' \
-          'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
-          '`gem uninstall google-protobuf -a; BUNDLE_FORCE_RUBY_PLATFORM=true bundle install`. ' \
-          'If the error persists, please contact support via <https://docs.datadoghq.com/help/> or ' \
-          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
-        )
-        @protobuf_loaded = false
-      end
-    end
-
-    private_class_method def self.native_library_failed_to_load?
-      success, exception = try_loading_native_library
-
-      unless success
-        if exception
-          'There was an error loading the profiling native extension due to ' \
-          "'#{exception.message}' at '#{exception.backtrace.first}'"
-        else
-          'The profiling native extension did not load correctly. ' \
-          'If the error persists, please contact support via <https://docs.datadoghq.com/help/> or ' \
-          'file a bug at <https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug>.'
-        end
-      end
-    end
-
-    private_class_method def self.try_loading_native_library
-      if Datadog::Core::Environment::VariableHelpers.env_to_bool('DD_PROFILING_NO_EXTENSION', false)
-        SKIPPED_NATIVE_EXTENSION_ONLY_ONCE.run do
-          Kernel.warn(
-            '[DDTRACE] Skipped loading of profiling native extension due to DD_PROFILING_NO_EXTENSION environment ' \
-            'variable being set. ' \
-            'This option is experimental and will lead to the profiler not working in future releases. ' \
-            'If you needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.'
-          )
-        end
-
-        return [true, nil]
-      end
-
-      begin
-        require "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-        success =
-          defined?(Datadog::Profiling::NativeExtension) && Datadog::Profiling::NativeExtension.send(:native_working?)
-        [success, nil]
-      rescue StandardError, LoadError => e
-        [false, e]
-      end
-    end
-
-    private_class_method def self.load_profiling
-      return false unless supported?
-
-      require 'ddtrace/profiling/ext/cpu'
-      require 'ddtrace/profiling/ext/forking'
-
-      require 'ddtrace/profiling/collectors/stack'
-      require 'ddtrace/profiling/exporter'
-      require 'ddtrace/profiling/recorder'
-      require 'ddtrace/profiling/scheduler'
-      require 'ddtrace/profiling/tasks/setup'
-      require 'ddtrace/profiling/transport/io'
-      require 'ddtrace/profiling/transport/http'
-      require 'ddtrace/profiling/profiler'
-      require 'ddtrace/profiling/native_extension'
-      require 'ddtrace/profiling/trace_identifiers/helper'
-      require 'ddtrace/profiling/pprof/pprof_pb'
-
-      true
-    end
-
-    load_profiling if supported?
-  end
-end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -1,75 +0,0 @@
-# typed: true
-require 'ddtrace/context'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  # opentracing.io compliant methods for distributing trace context
-  # between two or more distributed services. Note this is very close
-  # to the HTTPPropagator; the key difference is the way gRPC handles
-  # header information (called "metadata") as it operates over HTTP2
-  module GRPCPropagator
-    include Ext::DistributedTracing
-
-    def self.inject!(context, metadata)
-      metadata[GRPC_METADATA_TRACE_ID] = context.trace_id.to_s
-      metadata[GRPC_METADATA_PARENT_ID] = context.span_id.to_s
-      metadata[GRPC_METADATA_SAMPLING_PRIORITY] = context.sampling_priority.to_s if context.sampling_priority
-      metadata[GRPC_METADATA_ORIGIN] = context.origin.to_s if context.origin
-    end
-
-    def self.extract(metadata)
-      metadata = Carrier.new(metadata)
-      return Datadog::Context.new unless metadata.valid?
-
-      Datadog::Context.new(trace_id: metadata.trace_id,
-                           span_id: metadata.parent_id,
-                           sampling_priority: metadata.sampling_priority,
-                           origin: metadata.origin)
-    end
-
-    # opentracing.io compliant carrier object
-    class Carrier
-      include Ext::DistributedTracing
-
-      def initialize(metadata = {})
-        @metadata = metadata || {}
-      end
-
-      def valid?
-        trace_id && parent_id
-      end
-
-      def trace_id
-        value = metadata_for_key(GRPC_METADATA_TRACE_ID).to_i
-        value if (1..Span::EXTERNAL_MAX_ID).cover? value
-      end
-
-      def parent_id
-        value = metadata_for_key(GRPC_METADATA_PARENT_ID).to_i
-        value if (1..Span::EXTERNAL_MAX_ID).cover? value
-      end
-
-      def sampling_priority
-        value = metadata_for_key(GRPC_METADATA_SAMPLING_PRIORITY)
-        value && value.to_i
-      end
-
-      def origin
-        value = metadata_for_key(GRPC_METADATA_ORIGIN)
-        value if value != ''
-      end
-
-      private
-
-      def metadata_for_key(key)
-        # metadata values can be arrays (multiple headers with the same key)
-        value = @metadata[key]
-        if value.is_a?(Array)
-          value.first
-        else
-          value
-        end
-      end
-    end
-  end
-end