ddtrace 0.54.2 → 1.0.0.beta1

data/lib/datadog/core/metrics/options.rb

@@ -0,0 +1,48 @@
+require 'datadog/core/metrics/ext'
+require 'datadog/core/environment/ext'
+require 'datadog/core/environment/identity'
+
+module Datadog
+  module Core
+    module Metrics
+      # For defining and adding default options to metrics
+      module Options
+        DEFAULT = {
+          tags: DEFAULT_TAGS = [
+            "#{Ext::TAG_LANG}:#{Environment::Identity.lang}".freeze,
+            "#{Ext::TAG_LANG_INTERPRETER}:#{Environment::Identity.lang_interpreter}".freeze,
+            "#{Ext::TAG_LANG_VERSION}:#{Environment::Identity.lang_version}".freeze,
+            "#{Ext::TAG_TRACER_VERSION}:#{Environment::Identity.tracer_version}".freeze
+          ].freeze
+        }.freeze
+
+        def metric_options(options = nil)
+          return default_metric_options if options.nil?
+
+          default_metric_options.merge(options) do |key, old_value, new_value|
+            case key
+            when :tags
+              old_value.dup.concat(new_value).uniq
+            else
+              new_value
+            end
+          end
+        end
+
+        def default_metric_options
+          # Return dupes, so that the constant isn't modified,
+          # and defaults are unfrozen for mutation in Statsd.
+          DEFAULT.dup.tap do |options|
+            options[:tags] = options[:tags].dup
+
+            env = Datadog.configuration.env
+            options[:tags] << "#{Environment::Ext::TAG_ENV}:#{env}" unless env.nil?
+
+            version = Datadog.configuration.version
+            options[:tags] << "#{Environment::Ext::TAG_VERSION}:#{version}" unless version.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/pin.rb

@@ -0,0 +1,75 @@
+# typed: false
+
+module Datadog
+  module Core
+    # A {Datadog::Core::Pin} sets metadata on a particular object.
+    #
+    # This is useful if you want the object to reflect
+    # customized behavior or attributes, like an eigenclass.
+    class Pin
+      def self.get_from(obj)
+        return nil unless obj.respond_to? :datadog_pin
+
+        obj.datadog_pin
+      end
+
+      def self.set_on(obj, **options)
+        if (pin = get_from(obj))
+          options.each { |k, v| pin[k] = v }
+        else
+          pin = new(**options)
+          pin.onto(obj)
+        end
+
+        pin
+      end
+
+      def initialize(**options)
+        @options = options
+      end
+
+      def [](name)
+        @options[name]
+      end
+
+      def []=(name, value)
+        @options[name] = value
+      end
+
+      def key?(name)
+        @options.key?(name)
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      def onto(obj)
+        unless obj.respond_to? :datadog_pin=
+          obj.instance_exec do
+            def datadog_pin=(pin)
+              @datadog_pin = pin
+            end
+          end
+        end
+
+        unless obj.respond_to? :datadog_pin
+          obj.instance_exec do
+            def datadog_pin
+              @datadog_pin
+            end
+          end
+        end
+
+        obj.datadog_pin = self
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      def to_s
+        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(', ')
+        "Pin(#{pretty_options})"
+      end
+
+      private
+
+      attr_accessor :options
+    end
+  end
+end

data/lib/datadog/core/runtime/ext.rb

@@ -0,0 +1,28 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Runtime
+      # @public_api
+      module Ext
+        TAG_ID = 'runtime-id'.freeze
+        TAG_LANG = 'language'.freeze
+        TAG_PID = 'system.pid'.freeze
+
+        # Metrics
+        # @public_api
+        module Metrics
+          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
+
+          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
+          METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
+          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
+          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'.freeze
+          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'.freeze
+
+          TAG_SERVICE = 'service'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/runtime/metrics.rb

@@ -0,0 +1,125 @@
+# typed: true
+require 'datadog/core/runtime/ext'
+
+require 'datadog/core/metrics/client'
+require 'datadog/core/environment/class_count'
+require 'datadog/core/environment/gc'
+require 'datadog/core/environment/thread_count'
+require 'datadog/core/environment/vm_cache'
+
+module Datadog
+  module Core
+    module Runtime
+      # For generating runtime metrics
+      class Metrics < Core::Metrics::Client
+        def initialize(**options)
+          super
+
+          # Initialize service list
+          @services = Set.new(options.fetch(:services, []))
+          @service_tags = nil
+          compile_service_tags!
+        end
+
+        # Associate service with runtime metrics
+        def register_service(service)
+          return unless enabled? && service
+
+          service = service.to_s
+
+          unless @services.include?(service)
+            # Add service to list and update services tag
+            services << service
+
+            # Recompile the service tags
+            compile_service_tags!
+          end
+        end
+
+        # Flush all runtime metrics to Statsd client
+        def flush
+          return unless enabled?
+
+          try_flush do
+            if Core::Environment::ClassCount.available?
+              gauge(Core::Runtime::Ext::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
+            end
+          end
+
+          try_flush do
+            if Core::Environment::ThreadCount.available?
+              gauge(Core::Runtime::Ext::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
+            end
+          end
+
+          try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
+
+          try_flush do
+            if Core::Environment::VMCache.available?
+              gauge(
+                Core::Runtime::Ext::Metrics::METRIC_GLOBAL_CONSTANT_STATE,
+                Core::Environment::VMCache.global_constant_state
+              )
+
+              # global_method_state is not available since Ruby >= 3.0,
+              # as method caching was moved to a per-class basis.
+              global_method_state = Core::Environment::VMCache.global_method_state
+              gauge(Core::Runtime::Ext::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
+            end
+          end
+        end
+
+        def gc_metrics
+          Core::Environment::GC.stat.flat_map do |k, v|
+            nested_gc_metric(Core::Runtime::Ext::Metrics::METRIC_GC_PREFIX, k, v)
+          end.to_h
+        end
+
+        def try_flush
+          yield
+        rescue StandardError => e
+          Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
+        end
+
+        def default_metric_options
+          # Return dupes, so that the constant isn't modified,
+          # and defaults are unfrozen for mutation in Statsd.
+          super.tap do |options|
+            options[:tags] = options[:tags].dup
+
+            # Add services dynamically because they might change during runtime.
+            options[:tags].concat(service_tags) unless service_tags.nil?
+          end
+        end
+
+        private
+
+        attr_reader \
+          :service_tags,
+          :services
+
+        def compile_service_tags!
+          @service_tags = services.to_a.collect do |service|
+            "#{Core::Runtime::Ext::Metrics::TAG_SERVICE}:#{service}".freeze
+          end
+        end
+
+        def nested_gc_metric(prefix, k, v)
+          path = "#{prefix}.#{k}"
+
+          if v.is_a?(Hash)
+            v.flat_map do |key, value|
+              nested_gc_metric(path, key, value)
+            end
+          else
+            [[to_metric_name(path), v]]
+          end
+        end
+
+        def to_metric_name(str)
+          str.downcase.gsub(/[-\s]/, '_')
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/compression.rb

@@ -0,0 +1,31 @@
+# typed: true
+require 'stringio'
+require 'zlib'
+
+module Datadog
+  module Core
+    module Utils
+      # Common database-related utility functions.
+      module Compression
+        module_function
+
+        def gzip(string, level: nil, strategy: nil)
+          sio = StringIO.new
+          sio.binmode
+          gz = Zlib::GzipWriter.new(sio, level, strategy)
+          gz.write(string)
+          gz.close
+          sio.string
+        end
+
+        def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+          sio = StringIO.new(string)
+          gz = Zlib::GzipReader.new(sio, encoding: encoding)
+          gz.read
+        ensure
+          gz && gz.close
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/forking.rb

@@ -0,0 +1,62 @@
+# typed: false
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for managing forking behavior
+      module Forking
+        def self.included(base)
+          base.prepend(ClassExtensions) if base.is_a?(Class)
+        end
+
+        def self.extended(base)
+          # Explicitly update PID here because there's a case where
+          # the code path that lazily updates the PID may not be exercised
+          # until after a fork occurs, thus causing the event to be missed.
+          # By eagerly setting this, we avoid this scenario.
+          base.update_fork_pid!
+        end
+
+        def after_fork!
+          if forked?
+            yield
+            update_fork_pid!
+            true
+          else
+            false
+          end
+        end
+
+        def forked?
+          Process.pid != fork_pid
+        end
+
+        def update_fork_pid!
+          @fork_pid = Process.pid
+        end
+
+        def fork_pid
+          @fork_pid ||= Process.pid
+        end
+
+        # Adds additional functionality for Classes that implement Forking
+        module ClassExtensions
+          # Addresses an edge case where forking before invoking #update_fork_pid! on the
+          # object will cause forking to not be detected in the fork when it should have.
+          #
+          # This wrapper prevents this by initializing the fork PID when the object is created.
+          if RUBY_VERSION >= '3'
+            def initialize(*args, **kwargs, &block)
+              super(*args, **kwargs, &block)
+              update_fork_pid!
+            end
+          else
+            def initialize(*args, &block)
+              super(*args, &block)
+              update_fork_pid!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/object_set.rb

@@ -0,0 +1,42 @@
+# typed: true
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Acts as a unique dictionary of objects
+      class ObjectSet
+        # You can provide a block that defines how the key
+        # for this message type is resolved.
+        def initialize(seed = 0, &block)
+          @sequence = Sequence.new(seed)
+          @items = {}
+          @key_block = block
+        end
+
+        # Submit an array of arguments that define the message.
+        # If they match an existing message, it will return the
+        # matching object. If it doesn't match, it will yield to
+        # the block with the next ID & args given.
+        def fetch(*args)
+          # TODO: Array hashing is **really** expensive, we probably want to get rid of it in the future
+          key = @key_block ? @key_block.call(*args) : args.hash
+          @items[key] ||= yield(@sequence.next, *args)
+        end
+
+        def length
+          @items.length
+        end
+
+        def objects
+          @items.values
+        end
+
+        def freeze
+          super
+          @items.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/only_once.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper class to execute something only once such as not repeating warning logs, and instrumenting classes
+      # only once.
+      #
+      # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).
+      #
+      # Note: In its current state, this class is not Ractor-safe.
+      # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+      # including an alternative implementation that is Ractor-safe once spent.
+      class OnlyOnce
+        def initialize
+          @mutex = Mutex.new
+          @ran_once = false
+        end
+
+        def run
+          @mutex.synchronize do
+            return if @ran_once
+
+            @ran_once = true
+
+            yield
+          end
+        end
+
+        def ran?
+          @mutex.synchronize { @ran_once }
+        end
+
+        private
+
+        def reset_ran_once_state_for_tests
+          @mutex.synchronize { @ran_once = false }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/sequence.rb

@@ -0,0 +1,20 @@
+# typed: true
+module Datadog
+  module Core
+    module Utils
+      # Generates values from a consistent sequence
+      class Sequence
+        def initialize(seed = 0, &block)
+          @current = seed
+          @next_item = block
+        end
+
+        def next
+          next_item = @next_item ? @next_item.call(@current) : @current
+          @current += 1
+          next_item
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/string_table.rb

@@ -0,0 +1,48 @@
+# typed: true
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Tracks strings and returns IDs
+      class StringTable
+        def initialize
+          @sequence = Sequence.new
+          @ids = { ''.freeze => @sequence.next }
+        end
+
+        # Returns an ID for the string
+        def fetch(string)
+          @ids[string.to_s] ||= @sequence.next
+        end
+
+        # Returns the canonical copy of this string
+        # Typically used for psuedo interning; reduce
+        # identical copies of a string to one object.
+        def fetch_string(string)
+          return nil if string.nil?
+
+          # Co-erce to string
+          string = string.to_s
+
+          # Add to string table if no match
+          @ids[string] = @sequence.next unless @ids.key?(string)
+
+          # Get and return matching string in table
+          # NOTE: Have to resolve the key and retrieve from table again
+          #       because "string" argument is not same object as string key.
+          id = @ids[string]
+          @ids.key(id)
+        end
+
+        def [](id)
+          @ids.key(id)
+        end
+
+        def strings
+          @ids.keys
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/time.rb

@@ -0,0 +1,53 @@
+# typed: true
+module Datadog
+  module Core
+    module Utils
+      # Common database-related utility functions.
+      module Time
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        module_function
+
+        # Current monotonic time
+        #
+        # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
+        # @return [Numeric] timestamp in the requested unit, since some unspecified starting point
+        def get_time(unit = :float_second)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+        end
+
+        # Current wall time.
+        #
+        # @return [Time] current time object
+        def now
+          ::Time.now
+        end
+
+        # Overrides the implementation of `#now
+        # with the provided callable.
+        #
+        # Overriding the method `#now` instead of
+        # indirectly calling `block` removes
+        # one level of method call overhead.
+        #
+        # @param block [Proc] block that returns a `Time` object representing the current wall time
+        def now_provider=(block)
+          define_singleton_method(:now, &block)
+        end
+
+        def measure
+          before = get_time
+          yield
+          after = get_time
+          after - before
+        end
+
+        def as_utc_epoch_ns(time)
+          # we use #to_r instead of #to_f because Float doesn't have enough precision to represent exact nanoseconds, see
+          # https://rubyapi.org/3.0/o/time#method-i-to_f
+          (time.to_r * 1_000_000_000).to_i
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils.rb

@@ -0,0 +1,114 @@
+# typed: true
+require 'datadog/core/utils/forking'
+require 'datadog/tracing/span'
+
+module Datadog
+  module Core
+    # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
+    # @public_api
+    module Utils
+      extend Forking
+
+      EMPTY_STRING = ''.encode(::Encoding::UTF_8).freeze
+      # We use a custom random number generator because we want no interference
+      # with the default one. Using the default prng, we could break code that
+      # would rely on srand/rand sequences.
+
+      # Return a randomly generated integer, valid as a Span ID or Trace ID.
+      # This method is thread-safe and fork-safe.
+      def self.next_id
+        after_fork! { reset! }
+        id_rng.rand(Tracing::Span::RUBY_MAX_ID) # TODO: This should never return zero
+      end
+
+      def self.id_rng
+        @id_rng ||= Random.new
+      end
+
+      def self.reset!
+        @id_rng = Random.new
+      end
+
+      private_class_method :id_rng, :reset!
+
+      # Stringifies `value` and ensures the outcome is
+      # string is no longer than `size`.
+      # `omission` replaces the end of the output if
+      # `value.to_s` does not fit in `size`, to signify
+      # truncation.
+      #
+      # If `omission.size` is larger than `size`, the output
+      # will still be `omission.size` in length.
+      # @!visibility private
+      def self.truncate(value, size, omission = '...'.freeze)
+        string = value.to_s
+
+        return string if string.size <= size
+
+        string = string.slice(0, size - 1)
+
+        if size < omission.size
+          string[0, size] = omission
+        else
+          string[size - omission.size, size] = omission
+        end
+
+        string
+      end
+
+      # Ensure `str` is a valid UTF-8, ready to be
+      # sent through the tracer transport.
+      #
+      # @param [String,#to_s] str object to be converted to a UTF-8 string
+      # @param [Boolean] binary whether to expect binary data in the `str` parameter
+      # @param [String] placeholder string to be returned when encoding fails
+      # @return a UTF-8 string version of `str`
+      # @!visibility private
+      def self.utf8_encode(str, binary: false, placeholder: EMPTY_STRING)
+        str = str.to_s
+
+        if binary
+          # This option is useful for "gracefully" displaying binary data that
+          # often contains text such as marshalled objects
+          str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+        elsif str.encoding == ::Encoding::UTF_8
+          str
+        elsif str.empty?
+          # DEV Optimization as `nil.to_s` is a very common source for an empty string,
+          # DEV but it comes encoded as US_ASCII.
+          EMPTY_STRING
+        else
+          str.encode(::Encoding::UTF_8)
+        end
+      rescue => e
+        Datadog.logger.debug("Error encoding string in UTF-8: #{e}")
+
+        placeholder
+      end
+
+      # @!visibility private
+      def self.without_warnings
+        # This is typically used when monkey patching functions such as
+        # intialize, which Ruby advices you not to. Use cautiously.
+        v = $VERBOSE
+        $VERBOSE = nil
+        begin
+          yield
+        ensure
+          $VERBOSE = v
+        end
+      end
+
+      # Extracts hostname and port from
+      # a string that contains both, separated by ':'.
+      # @return [String,Integer] hostname and port
+      # @return [nil] if format did not match
+      def self.extract_host_port(host_port)
+        match = /^([^:]+):(\d+)$/.match(host_port)
+        return unless match
+
+        [match[1], match[2].to_i]
+      end
+    end
+  end
+end