ddtrace 0.45.0 → 0.50.0

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,100 @@
+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, 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_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_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

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

@@ -0,0 +1,33 @@
+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,21 @@
+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/io.rb

@@ -0,0 +1,30 @@
+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/io/client.rb

@@ -0,0 +1,27 @@
+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,16 @@
+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/parcel.rb

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

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

@@ -0,0 +1,8 @@
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling response
+      module Response; end
+    end
+  end
+end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -19,6 +19,7 @@ module Datadog
     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,