ddtrace 0.47.0 → 0.48.0

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

@@ -0,0 +1,77 @@
+require 'ddtrace'
+require 'ddtrace/utils/only_once'
+require 'ddtrace/profiling'
+require 'ddtrace/profiling/ext/cpu'
+require 'ddtrace/profiling/ext/forking'
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Takes care of loading our extensions/monkey patches to handle fork() and CPU profiling.
+      class Setup
+        ACTIVATE_EXTENSIONS_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
+        def run
+          ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
+            begin
+              activate_forking_extensions
+              activate_cpu_extensions
+              setup_at_fork_hooks
+            rescue StandardError, ScriptError => e
+              log "[DDTRACE] Main extensions unavailable. Cause: #{e.message} Location: #{e.backtrace.first}"
+            end
+          end
+        end
+
+        private
+
+        def activate_forking_extensions
+          if Ext::Forking.supported?
+            Ext::Forking.apply!
+          elsif Datadog.configuration.profiling.enabled
+            # Log warning if profiling was supposed to be activated.
+            log '[DDTRACE] Forking extensions skipped; forking not supported.'
+          end
+        rescue StandardError, ScriptError => e
+          log "[DDTRACE] Forking extensions unavailable. Cause: #{e.message} Location: #{e.backtrace.first}"
+        end
+
+        def activate_cpu_extensions
+          if Ext::CPU.supported?
+            Ext::CPU.apply!
+          elsif Datadog.configuration.profiling.enabled
+            # Log warning if profiling was supposed to be activated.
+            log "[DDTRACE] CPU profiling skipped because native CPU time is not supported: #{Ext::CPU.unsupported_reason}."
+          end
+        rescue StandardError, ScriptError => e
+          log "[DDTRACE] CPU profiling unavailable. Cause: #{e.message} Location: #{e.backtrace.first}"
+        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
+                log "[DDTRACE] Error during post-fork hooks. Cause: #{e.message} Location: #{e.backtrace.first}"
+              end
+            end
+          end
+        end
+
+        def log(message)
+          # Print to STDOUT for now because logging may not be setup yet...
+          puts message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Datadog
+  module Profiling
+    module Transport
+      # Generic interface for profiling transports
+      module Client
+        def send_profiling_flush(flush)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+require 'ddtrace/ext/runtime'
+require 'ddtrace/ext/transport'
+
+require 'ddtrace/runtime/container'
+
+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
+      # TODO: Consolidate with Dataog::Transport::HTTP
+      # Namespace for HTTP transport components
+      module HTTP
+        module_function
+
+        # Builds a new Transport::HTTP::Client
+        def new(&block)
+          Builder.new(&block).to_transport
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def default(options = {})
+          new do |transport|
+            transport.headers default_headers
+
+            # Configure adapter & API
+            if options[:site] && options[:api_key]
+              configure_for_agentless(transport, options)
+            else
+              configure_for_agent(transport, options)
+            end
+
+            # Additional options
+            unless options.empty?
+              # Change default API
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+
+              # Add headers
+              transport.headers options[:headers] if options.key?(:headers)
+
+              # Execute on_build callback
+              options[:on_build].call(transport) if options[:on_build].is_a?(Proc)
+            end
+
+            # Call block to apply any customization, if provided.
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Datadog::Ext::Runtime::LANG,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Datadog::Ext::Runtime::LANG_VERSION,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Ext::Runtime::LANG_INTERPRETER,
+            Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Datadog::Ext::Runtime::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Runtime::Container.container_id
+            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        def default_adapter
+          :net_http
+        end
+
+        def default_hostname
+          ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
+        end
+
+        def default_port
+          ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
+        end
+
+        def configure_for_agent(transport, options = {})
+          apis = API.agent_defaults
+
+          hostname = options[:hostname] || default_hostname
+          port = options[:port] || default_port
+
+          adapter_options = {}
+          adapter_options[:timeout] = options[:timeout] if options.key?(:timeout)
+          adapter_options[:ssl] = options[:ssl] if options.key?(:ssl)
+
+          transport.adapter default_adapter, hostname, port, adapter_options
+          transport.api API::V1, apis[API::V1], default: true
+        end
+
+        def configure_for_agentless(transport, options = {})
+          apis = API.api_defaults
+
+          site_uri = URI(format(Datadog::Ext::Profiling::Transport::HTTP::URI_TEMPLATE_DD_API, options[:site]))
+          hostname = options[:hostname] || site_uri.host
+          port = options[:port] || site_uri.port
+
+          adapter_options = {}
+          adapter_options[:timeout] = options[:timeout] if options.key?(:timeout)
+          adapter_options[:ssl] = options[:ssl] || (site_uri.scheme == 'https'.freeze)
+
+          transport.adapter default_adapter, hostname, port, adapter_options
+          transport.api API::V1, apis[API::V1], default: true
+          transport.headers(Datadog::Ext::Transport::HTTP::HEADER_DD_API_KEY => options[:api_key])
+        end
+
+        # Add adapters to registry
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, :net_http)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, :test)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, :unix)
+
+        private \
+          :configure_for_agent,
+          :configure_for_agentless
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+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/api/endpoint.rb

@@ -0,0 +1,90 @@
+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
+
+            attr_reader \
+              :encoder
+
+            def initialize(path, encoder, options = {})
+              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, types = build_pprof(flush)
+
+              form = {
+                # NOTE: Redundant w/ 'runtime-id' tag below; may want to remove this later.
+                FORM_FIELD_RUNTIME_ID => flush.runtime_id,
+                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_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}"
+                ],
+                FORM_FIELD_DATA => pprof_file,
+                FORM_FIELD_RUNTIME => flush.language,
+                FORM_FIELD_FORMAT => FORM_FIELD_FORMAT_PPROF
+              }
+
+              # Add types
+              form[FORM_FIELD_TYPES] = types.join(',')
+
+              # 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)
+
+              # Wrap pprof as a gzipped file
+              gzipped_data = Datadog::Utils::Compression.gzip(pprof.data)
+              pprof_file = Datadog::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_data),
+                HEADER_CONTENT_TYPE_OCTET_STREAM,
+                PPROF_DEFAULT_FILENAME
+              )
+
+              [pprof_file, [FORM_FIELD_TYPES_AUTO]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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,40 @@
+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/builder.rb

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