ddtrace 1.1.0 → 1.4.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
-
-        OldFlush.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/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

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

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

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

data/lib/datadog/tracing/distributed/parser.rb

@@ -1,70 +0,0 @@
-# typed: false
-
-require 'datadog/tracing/span'
-require 'datadog/tracing/distributed/helpers'
-
-module Datadog
-  module Tracing
-    module Distributed
-      # Parser provides easy access and validation methods for Rack headers
-      class Parser
-        def initialize(env)
-          @env = env
-        end
-
-        # TODO: Don't assume Rack format.
-        #       Make distributed tracing headers apathetic.
-        def header(name)
-          rack_header = "http-#{name}".upcase!.tr('-', '_')
-
-          hdr = @env[rack_header]
-
-          # Only return the value if it is not an empty string
-          hdr if hdr != ''
-        end
-
-        def id(hdr, base = 10)
-          value_to_id(header(hdr), base)
-        end
-
-        def value_to_id(value, base = 10)
-          id = value_to_number(value, base)
-
-          # Return early if we could not parse a number
-          return if id.nil?
-
-          # Zero or greater than max allowed value of 2**64
-          return if id.zero? || id > Span::EXTERNAL_MAX_ID
-
-          id < 0 ? id + (2**64) : id
-        end
-
-        def number(hdr, base = 10)
-          value_to_number(header(hdr), base)
-        end
-
-        def value_to_number(value, base = 10)
-          # It's important to make a difference between no header,
-          # and a header defined to zero.
-          return if value.nil?
-
-          # Be sure we have a string
-          value = value.to_s
-
-          # If we are parsing base16 number then truncate to 64-bit
-          value = Helpers.truncate_base16_number(value) if base == 16
-
-          # Convert header to an integer
-          # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
-          num = value.to_i(base)
-
-          # Ensure the parsed number is the same as the original string value
-          # e.g. We want to make sure to throw away `'nan'.to_i == 0`
-          return unless num.to_s(base) == value
-
-          num
-        end
-      end
-    end
-  end
-end