ddtrace 0.40.0 → 0.50.0

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,
@@ -38,24 +39,36 @@ module Datadog
       end
 
       def trace_id
-        value = @metadata[GRPC_METADATA_TRACE_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        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[GRPC_METADATA_PARENT_ID].to_i
-        value if (1..Span::MAX_ID).cover? value
+        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[GRPC_METADATA_SAMPLING_PRIORITY]
+        value = metadata_for_key(GRPC_METADATA_SAMPLING_PRIORITY)
         value && value.to_i
       end
 
       def origin
-        value = @metadata[GRPC_METADATA_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

data/lib/ddtrace/propagation/http_propagator.rb

@@ -26,7 +26,14 @@ module Datadog
       # Inject all configured propagation styles
       ::Datadog.configuration.distributed_tracing.propagation_inject_style.each do |style|
         propagator = PROPAGATION_STYLES[style]
-        propagator.inject!(context, env) unless propagator.nil?
+        begin
+          propagator.inject!(context, env) unless propagator.nil?
+        rescue => e
+          Datadog.logger.error(
+            'Error injecting propagated context into the environment. ' \
+            "Cause: #{e} Location: #{e.backtrace.first}"
+          )
+        end
       end
     end
 
@@ -42,7 +49,15 @@ module Datadog
 
         # Extract context
         # DEV: `propagator.extract` will return `nil`, where `HTTPPropagator#extract` will not
-        extracted_context = propagator.extract(env)
+        begin
+          extracted_context = propagator.extract(env)
+        rescue => e
+          Datadog.logger.error(
+            'Error extracting propagated context from the environment. ' \
+            "Cause: #{e} Location: #{e.backtrace.first}"
+          )
+        end
+
         # Skip this style if no valid headers were found
         next if extracted_context.nil?
 

data/lib/ddtrace/quantization/http.rb

@@ -61,6 +61,7 @@ module Datadog
       # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
       def collect_query(query, options = {})
         return query unless block_given?
+
         uniq = options[:uniq].nil? ? false : options[:uniq]
         keys = Set.new
 

data/lib/ddtrace/runtime/cgroup.rb

@@ -4,7 +4,7 @@ module Datadog
   module Runtime
     # For control groups
     module Cgroup
-      LINE_REGEX = /^(\d+):([^:]*):(.+)$/
+      LINE_REGEX = /^(\d+):([^:]*):(.+)$/.freeze
 
       Descriptor = Struct.new(
         :id,
@@ -21,7 +21,7 @@ module Datadog
             filepath = "/proc/#{process}/cgroup"
 
             if File.exist?(filepath)
-              File.open("/proc/#{process}/cgroup").each do |line|
+              File.foreach("/proc/#{process}/cgroup") do |line|
                 line = line.strip
                 descriptors << parse(line) unless line.empty?
               end

data/lib/ddtrace/runtime/container.rb

@@ -8,8 +8,10 @@ module Datadog
       UUID_PATTERN = '[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}'.freeze
       CONTAINER_PATTERN = '[0-9a-f]{64}'.freeze
 
-      POD_REGEX = /(pod)?(#{UUID_PATTERN})(?:.slice)?$/
-      CONTAINER_REGEX = /(#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/
+      PLATFORM_REGEX = /(?<platform>.*?)(?:.slice)?$/.freeze
+      POD_REGEX = /(?<pod>(pod)?#{UUID_PATTERN})(?:.slice)?$/.freeze
+      CONTAINER_REGEX = /(?<container>#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/.freeze
+      FARGATE_14_CONTAINER_REGEX = /(?<container>[0-9a-f]{32}-[0-9]{10})/.freeze
 
       Descriptor = Struct.new(
         :platform,
@@ -32,39 +34,51 @@ module Datadog
       end
 
       def descriptor
-        @descriptor ||= begin
-          Descriptor.new.tap do |descriptor|
-            begin
-              Cgroup.descriptors.each do |cgroup_descriptor|
-                # Parse container data from cgroup descriptor
-                path = cgroup_descriptor.path
-                next if path.nil?
+        @descriptor ||= Descriptor.new.tap do |descriptor|
+          begin
+            Cgroup.descriptors.each do |cgroup_descriptor|
+              # Parse container data from cgroup descriptor
+              path = cgroup_descriptor.path
+              next if path.nil?
 
-                # Split path into parts
-                parts = path.split('/')
-                parts.shift # Remove leading empty part
-                next if parts.length < 2
+              # Split path into parts
+              parts = path.split('/')
+              parts.shift # Remove leading empty part
 
-                # Read info from path
-                platform = parts[0]
-                container_id = parts[-1][CONTAINER_REGEX]
-                task_uid = parts[-2][POD_REGEX]
+              # Read info from path
+              next if parts.empty?
 
-                # If container ID wasn't found, ignore.
-                # Path might describe a non-container environment.
-                next if container_id.nil?
+              platform = parts[0][PLATFORM_REGEX, :platform]
+              container_id, task_uid = nil
 
-                descriptor.platform = platform
-                descriptor.container_id = container_id
-                descriptor.task_uid = task_uid
-
-                break
+              case parts.length
+              when 0..1
+                next
+              when 2
+                container_id = parts[-1][CONTAINER_REGEX, :container] \
+                               || parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
+              else
+                if (container_id = parts[-1][CONTAINER_REGEX, :container])
+                  task_uid = parts[-2][POD_REGEX, :pod]
+                else
+                  container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
+                end
               end
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
-              )
+
+              # If container ID wasn't found, ignore.
+              # Path might describe a non-container environment.
+              next if container_id.nil?
+
+              descriptor.platform = platform
+              descriptor.container_id = container_id
+              descriptor.task_uid = task_uid
+
+              break
             end
+          rescue StandardError => e
+            Datadog.logger.error(
+              "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
+            )
           end
         end
       end