ddtrace 1.0.0 → 1.9.0

data/lib/datadog/profiling/recorder.rb

@@ -1,117 +0,0 @@
-# typed: true
-
-require 'datadog/profiling/buffer'
-require 'datadog/profiling/flush'
-
-module Datadog
-  module Profiling
-    # Stores profiling events gathered by `Collector`s
-    class Recorder
-      attr_reader :max_size
-
-      # TODO: Why does the Recorder directly reference the `code_provenance_collector`?
-      #
-      # For starters, this is weird/a problem because the relationship is supposed to go in the other direction:
-      # collectors are supposed to record their results in the `Recorder`, rather than the `Recorder` having to know
-      # about individual collectors.
-      #
-      # But the `code_provenance_collector` is different from other existing and potential collectors because it is not
-      # asynchronous. It does not gather data over time and record it as it goes. Instead, you call it once per profile,
-      # synchronously, and just use what it spits out.
-      #
-      # The current design of the `Recorder` is quite tied to the asynchronous model. Modifying our current design
-      # to support synchronous collectors is non-trivial, and I decided not to go through with it because we're
-      # soon going to replace the `Recorder` and many other existing classes with a
-      # [libddprof](https://github.com/datadog/libddprof)-based implementation, and thus I don't think massive refactors
-      # are worth it before moving to libddprof.
-
-      def initialize(event_classes, max_size, code_provenance_collector:, last_flush_time: Time.now.utc)
-        @buffers = {}
-        @last_flush_time = last_flush_time
-        @max_size = max_size
-        @code_provenance_collector = code_provenance_collector
-
-        # Add a buffer for each class
-        event_classes.each do |event_class|
-          @buffers[event_class] = Profiling::Buffer.new(max_size)
-        end
-
-        # Event classes can only be added ahead of time
-        @buffers.freeze
-      end
-
-      def [](event_class)
-        @buffers[event_class]
-      end
-
-      def push(events)
-        if events.is_a?(Array)
-          # Push multiple events
-          event_class = events.first.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].concat(events)
-        else
-          # Push single event
-          event_class = events.class
-          raise UnknownEventError, event_class unless @buffers.key?(event_class)
-
-          @buffers[event_class].push(events)
-        end
-      end
-
-      def flush
-        event_count = 0
-
-        event_groups, start, finish = update_time do
-          @buffers.collect do |event_class, buffer|
-            events = buffer.pop
-            next if events.empty?
-
-            event_count += events.length
-            EventGroup.new(event_class, events)
-          end.compact
-        end
-
-        code_provenance = @code_provenance_collector.refresh.generate_json if @code_provenance_collector
-
-        Flush.new(
-          start: start,
-          finish: finish,
-          event_groups: event_groups,
-          event_count: event_count,
-          code_provenance: code_provenance,
-        )
-      end
-
-      # NOTE: Remember that if the recorder is being accessed by multiple threads, this is an inherently racy operation.
-      def empty?
-        @buffers.values.all?(&:empty?)
-      end
-
-      # Error when event of an unknown type is used with the Recorder
-      class UnknownEventError < StandardError
-        attr_reader :event_class
-
-        def initialize(event_class)
-          @event_class = event_class
-        end
-
-        def message
-          @message ||= "Unknown event class '#{event_class}' for profiling recorder."
-        end
-      end
-
-      private
-
-      def update_time
-        start = @last_flush_time
-        result = yield
-        @last_flush_time = Time.now.utc
-
-        # Return event groups, start time, finish time
-        [result, start, @last_flush_time]
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# 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/datadog/profiling/transport/http/api/endpoint.rb

@@ -1,107 +0,0 @@
-# typed: true
-
-require 'datadog/core/utils/compression'
-require 'datadog/core/vendor/multipart-post/multipart/post/composite_read_io'
-require 'datadog/profiling/ext'
-require 'datadog/profiling/transport/http/response'
-require 'ddtrace/transport/http/api/endpoint'
-
-module Datadog
-  module Profiling
-    module Transport
-      module HTTP
-        module API
-          # Datadog API endpoint for profiling
-          class Endpoint < Datadog::Transport::HTTP::API::Endpoint
-            include Profiling::Ext::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?
-
-              # May not be available/enabled
-              form[FORM_FIELD_CODE_PROVENANCE_DATA] = build_code_provenance(flush) if flush.code_provenance
-
-              form
-            end
-
-            def build_pprof(flush)
-              pprof = encoder.encode(flush)
-
-              gzipped_pprof_data = Core::Utils::Compression.gzip(pprof.data)
-
-              Core::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_pprof_data),
-                HEADER_CONTENT_TYPE_OCTET_STREAM,
-                PPROF_DEFAULT_FILENAME
-              )
-            end
-
-            def build_code_provenance(flush)
-              gzipped_code_provenance = Core::Utils::Compression.gzip(flush.code_provenance)
-
-              Core::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_code_provenance),
-                HEADER_CONTENT_TYPE_OCTET_STREAM,
-                CODE_PROVENANCE_FILENAME,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/api/instance'
-require 'datadog/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/datadog/profiling/transport/http/api/spec.rb

@@ -1,42 +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/datadog/profiling/transport/http/api.rb

@@ -1,45 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/api/map'
-require 'datadog/profiling/encoding/profile'
-require 'datadog/profiling/transport/http/api/spec'
-require 'datadog/profiling/transport/http/api/instance'
-require 'datadog/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/datadog/profiling/transport/http/builder.rb

@@ -1,30 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/builder'
-
-require 'datadog/profiling/transport/http/api'
-require 'datadog/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/datadog/profiling/transport/http/client.rb

@@ -1,35 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/client'
-require 'datadog/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/datadog/profiling/transport/http/response.rb

@@ -1,23 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/http/response'
-require 'datadog/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/datadog/profiling/transport/http.rb

@@ -1,112 +0,0 @@
-# typed: true
-
-require 'datadog/core/environment/ext'
-require 'ddtrace/transport/ext'
-
-require 'datadog/core/environment/container'
-require 'datadog/core/environment/variable_helpers'
-
-require 'datadog/profiling/transport/http/builder'
-require 'datadog/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::Transport::Ext::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER => Core::Environment::Ext::LANG_INTERPRETER,
-            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Core::Environment::Ext::TRACER_VERSION
-          }.tap do |headers|
-            # Add container ID, if present.
-            container_id = Core::Environment::Container.container_id
-            headers[Datadog::Transport::Ext::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(Profiling::Ext::Transport::HTTP::URI_TEMPLATE_DD_API, site))
-          hostname = site_uri.host
-          port = site_uri.port
-
-          transport.adapter(
-            Datadog::Transport::Ext::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::Transport::Ext::HTTP::HEADER_DD_API_KEY => api_key)
-        end
-
-        private_class_method def self.agentless_allowed?
-          Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
-        end
-
-        # Add adapters to registry
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net,
-                                                        Datadog::Transport::Ext::HTTP::ADAPTER)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test,
-                                                        Datadog::Transport::Ext::Test::ADAPTER)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket,
-                                                        Datadog::Transport::Ext::UnixSocket::ADAPTER)
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# typed: true
-
-require 'ddtrace/transport/io/client'
-require 'datadog/profiling/transport/client'
-require 'datadog/profiling/transport/request'
-require 'datadog/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/datadog/profiling/transport/io/response.rb

@@ -1,18 +0,0 @@
-# typed: strict
-
-require 'ddtrace/transport/io/response'
-require 'datadog/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/datadog/profiling/transport/io.rb

@@ -1,32 +0,0 @@
-# typed: true
-
-require 'datadog/profiling/transport/io/client'
-require 'datadog/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/datadog/profiling/transport/parcel.rb

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