ddtrace 0.38.0

data/lib/ddtrace/runtime/class_count.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Runtime
+    # Retrieves number of classes from runtime
+    module ClassCount
+      module_function
+
+      def value
+        ::ObjectSpace.count_objects[:T_CLASS]
+      end
+
+      def available?
+        ::ObjectSpace.respond_to?(:count_objects) \
+          && ::ObjectSpace.count_objects.key?(:T_CLASS)
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/container.rb

@@ -0,0 +1,73 @@
+require 'ddtrace/ext/runtime'
+require 'ddtrace/runtime/cgroup'
+
+module Datadog
+  module Runtime
+    # For container environments
+    module Container
+      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)?$/
+
+      Descriptor = Struct.new(
+        :platform,
+        :container_id,
+        :task_uid
+      )
+
+      module_function
+
+      def platform
+        descriptor.platform
+      end
+
+      def container_id
+        descriptor.container_id
+      end
+
+      def task_uid
+        descriptor.task_uid
+      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?
+
+                # Split path into parts
+                parts = path.split('/')
+                parts.shift # Remove leading empty part
+                next if parts.length < 2
+
+                # Read info from path
+                platform = parts[0]
+                container_id = parts[-1][CONTAINER_REGEX]
+                task_uid = parts[-2][POD_REGEX]
+
+                # 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
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/gc.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Runtime
+    # Retrieves garbage collection statistics
+    module GC
+      module_function
+
+      def stat
+        ::GC.stat
+      end
+
+      def available?
+        defined?(::GC) && ::GC.respond_to?(:stat)
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/identity.rb

@@ -0,0 +1,41 @@
+require 'securerandom'
+require 'ddtrace/ext/runtime'
+
+module Datadog
+  module Runtime
+    # For runtime identity
+    module Identity
+      module_function
+
+      # Retrieves number of classes from runtime
+      def id
+        @pid ||= Process.pid
+        @id ||= SecureRandom.uuid
+
+        # Check if runtime has changed, e.g. forked.
+        if Process.pid != @pid
+          @pid = Process.pid
+          @id = SecureRandom.uuid
+        end
+
+        @id
+      end
+
+      def lang
+        Ext::Runtime::LANG
+      end
+
+      def lang_interpreter
+        Ext::Runtime::LANG_INTERPRETER
+      end
+
+      def lang_version
+        Ext::Runtime::LANG_VERSION
+      end
+
+      def tracer_version
+        Ext::Runtime::TRACER_VERSION
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/metrics.rb

@@ -0,0 +1,96 @@
+require 'ddtrace/ext/runtime'
+
+require 'ddtrace/metrics'
+require 'ddtrace/runtime/class_count'
+require 'ddtrace/runtime/gc'
+require 'ddtrace/runtime/identity'
+require 'ddtrace/runtime/thread_count'
+
+module Datadog
+  module Runtime
+    # For generating runtime metrics
+    class Metrics < Datadog::Metrics
+      def initialize(options = {})
+        super
+
+        # Initialize service list
+        @services = Set.new(options.fetch(:services, []))
+        @service_tags = nil
+        compile_service_tags!
+      end
+
+      def associate_with_span(span)
+        return if !enabled? || span.nil?
+
+        # Register service as associated with metrics
+        register_service(span.service) unless span.service.nil?
+
+        # Tag span with language and runtime ID for association with metrics
+        span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
+      end
+
+      # Associate service with runtime metrics
+      def register_service(service)
+        return if !enabled? || service.nil?
+
+        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 { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
+        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
+        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+      end
+
+      def gc_metrics
+        Hash[
+          GC.stat.map do |k, v|
+            next if v.is_a?(Hash) # TODO: JRuby supports additional nested metrics
+
+            ["#{Ext::Runtime::Metrics::METRIC_GC_PREFIX}.#{k}", v]
+          end
+        ]
+      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|
+          "#{Ext::Runtime::Metrics::TAG_SERVICE}:#{service}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/object_space.rb

@@ -0,0 +1,19 @@
+require 'objspace'
+
+module Datadog
+  module Runtime
+    # Retrieves garbage collection statistics
+    module ObjectSpace
+      module_function
+
+      def estimate_bytesize(object)
+        return 0 unless ::ObjectSpace.respond_to?(:memsize_of)
+
+        # Rough calculation of bytesize; not very accurate.
+        object.instance_variables.inject(::ObjectSpace.memsize_of(object)) do |sum, var|
+          sum + ::ObjectSpace.memsize_of(object.instance_variable_get(var))
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/socket.rb

@@ -0,0 +1,14 @@
+require 'socket'
+
+module Datadog
+  module Runtime
+    # For runtime identity
+    module Socket
+      module_function
+
+      def hostname
+        ::Socket.gethostname
+      end
+    end
+  end
+end

data/lib/ddtrace/runtime/thread_count.rb

@@ -0,0 +1,16 @@
+module Datadog
+  module Runtime
+    # Retrieves number of threads from runtime
+    module ThreadCount
+      module_function
+
+      def value
+        Thread.list.count
+      end
+
+      def available?
+        Thread.respond_to?(:list)
+      end
+    end
+  end
+end

data/lib/ddtrace/sampler.rb

@@ -0,0 +1,292 @@
+require 'forwardable'
+
+require 'ddtrace/ext/priority'
+require 'ddtrace/diagnostics/health'
+
+module Datadog
+  # \Sampler performs client-side trace sampling.
+  class Sampler
+    def sample?(_span)
+      raise NotImplementedError, 'Samplers must implement the #sample? method'
+    end
+
+    def sample!(_span)
+      raise NotImplementedError, 'Samplers must implement the #sample! method'
+    end
+
+    def sample_rate(span)
+      raise NotImplementedError, 'Samplers must implement the #sample_rate method'
+    end
+  end
+
+  # \AllSampler samples all the traces.
+  class AllSampler < Sampler
+    def sample?(span)
+      true
+    end
+
+    def sample!(span)
+      span.sampled = true
+    end
+
+    def sample_rate(*_)
+      1.0
+    end
+  end
+
+  # \RateSampler is based on a sample rate.
+  class RateSampler < Sampler
+    KNUTH_FACTOR = 1111111111111111111
+    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
+
+    # Initialize a \RateSampler.
+    # This sampler keeps a random subset of the traces. Its main purpose is to
+    # reduce the instrumentation footprint.
+    #
+    # * +sample_rate+: the sample rate as a \Float between 0.0 and 1.0. 0.0
+    #   means that no trace will be sampled; 1.0 means that all traces will be
+    #   sampled.
+    def initialize(sample_rate = 1.0)
+      unless sample_rate > 0.0 && sample_rate <= 1.0
+        Datadog.logger.error('sample rate is not between 0 and 1, disabling the sampler')
+        sample_rate = 1.0
+      end
+
+      self.sample_rate = sample_rate
+    end
+
+    def sample_rate(*_)
+      @sample_rate
+    end
+
+    def sample_rate=(sample_rate)
+      @sample_rate = sample_rate
+      @sampling_id_threshold = sample_rate * Span::MAX_ID
+    end
+
+    def sample?(span)
+      ((span.trace_id * KNUTH_FACTOR) % Datadog::Span::MAX_ID) <= @sampling_id_threshold
+    end
+
+    def sample!(span)
+      (span.sampled = sample?(span)).tap do |sampled|
+        span.set_metric(SAMPLE_RATE_METRIC_KEY, @sample_rate) if sampled
+      end
+    end
+  end
+
+  # Samples at different rates by key.
+  class RateByKeySampler < Sampler
+    attr_reader \
+      :default_key
+
+    def initialize(default_key, default_rate = 1.0, &block)
+      raise ArgumentError, 'No resolver given!' unless block_given?
+
+      @default_key = default_key
+      @resolver = block
+      @mutex = Mutex.new
+      @samplers = {}
+
+      set_rate(default_key, default_rate)
+    end
+
+    def resolve(span)
+      @resolver.call(span)
+    end
+
+    def default_sampler
+      @samplers[default_key]
+    end
+
+    def sample?(span)
+      key = resolve(span)
+
+      @mutex.synchronize do
+        @samplers.fetch(key, default_sampler).sample?(span)
+      end
+    end
+
+    def sample!(span)
+      key = resolve(span)
+
+      @mutex.synchronize do
+        @samplers.fetch(key, default_sampler).sample!(span)
+      end
+    end
+
+    def sample_rate(span)
+      key = resolve(span)
+
+      @mutex.synchronize do
+        @samplers.fetch(key, default_sampler).sample_rate
+      end
+    end
+
+    def update(key, rate)
+      @mutex.synchronize do
+        set_rate(key, rate)
+      end
+    end
+
+    def update_all(rate_by_key)
+      @mutex.synchronize do
+        rate_by_key.each { |key, rate| set_rate(key, rate) }
+      end
+    end
+
+    def delete(key)
+      @mutex.synchronize do
+        @samplers.delete(key)
+      end
+    end
+
+    def delete_if(&block)
+      @mutex.synchronize do
+        @samplers.delete_if(&block)
+      end
+    end
+
+    def length
+      @samplers.length
+    end
+
+    private
+
+    def set_rate(key, rate)
+      @samplers[key] ||= RateSampler.new(rate)
+      @samplers[key].sample_rate = rate
+    end
+  end
+
+  # \RateByServiceSampler samples different services at different rates
+  class RateByServiceSampler < RateByKeySampler
+    DEFAULT_KEY = 'service:,env:'.freeze
+
+    def initialize(default_rate = 1.0, options = {})
+      super(DEFAULT_KEY, default_rate, &method(:key_for))
+      @env = options[:env]
+    end
+
+    def update(rate_by_service)
+      # Remove any old services
+      delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
+
+      # Update each service rate
+      update_all(rate_by_service)
+
+      # Emit metric for service cache size
+      Datadog.health_metrics.sampling_service_cache_length(length)
+    end
+
+    private
+
+    def key_for(span)
+      # Resolve env dynamically, if Proc is given.
+      env = @env.is_a?(Proc) ? @env.call : @env
+
+      "service:#{span.service},env:#{env}"
+    end
+  end
+
+  # \PrioritySampler
+  class PrioritySampler
+    extend Forwardable
+
+    attr_reader :pre_sampler, :priority_sampler
+
+    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
+
+    def initialize(opts = {})
+      @pre_sampler = opts[:base_sampler] || AllSampler.new
+      @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new
+    end
+
+    def sample?(span)
+      @pre_sampler.sample?(span)
+    end
+
+    def sample!(span)
+      # If pre-sampling is configured, do it first. (By default, this will sample at 100%.)
+      # NOTE: Pre-sampling at rates < 100% may result in partial traces; not recommended.
+      span.sampled = pre_sample?(span) ? @pre_sampler.sample!(span) : true
+
+      if span.sampled
+        # If priority sampling has already been applied upstream, use that, otherwise...
+        unless priority_assigned_upstream?(span)
+          # Roll the dice and determine whether how we set the priority.
+          priority = priority_sample!(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+
+          assign_priority!(span, priority)
+        end
+      else
+        # If discarded by pre-sampling, set "reject" priority, so other
+        # services for the same trace don't sample needlessly.
+        assign_priority!(span, Datadog::Ext::Priority::AUTO_REJECT)
+      end
+
+      span.sampled
+    end
+
+    def_delegators :@priority_sampler, :update
+
+    private
+
+    def pre_sample?(span)
+      case @pre_sampler
+      when RateSampler
+        @pre_sampler.sample_rate < 1.0
+      when RateByServiceSampler
+        @pre_sampler.sample_rate(span) < 1.0
+      else
+        true
+      end
+    end
+
+    def priority_assigned_upstream?(span)
+      span.context && !span.context.sampling_priority.nil?
+    end
+
+    def priority_sample!(span)
+      preserving_sampling(span) do
+        @priority_sampler.sample!(span)
+      end
+    end
+
+    # Ensures the span is always propagated to the writer and that
+    # the sample rate metric represents the true client-side sampling.
+    def preserving_sampling(span)
+      pre_sample_rate_metric = span.get_metric(SAMPLE_RATE_METRIC_KEY)
+
+      yield.tap do
+        # NOTE: We'll want to leave `span.sampled = true` here; all spans for priority sampling must
+        #       be sent to the agent. Otherwise metrics for traces will not be accurate, since the
+        #       agent will have an incomplete dataset.
+        #
+        #       We also ensure that the agent knows we that our `post_sampler` is not performing true sampling,
+        #       to avoid erroneous metric upscaling.
+        span.sampled = true
+        if pre_sample_rate_metric
+          # Restore true sampling metric, as only the @pre_sampler can reject traces
+          span.set_metric(SAMPLE_RATE_METRIC_KEY, pre_sample_rate_metric)
+        else
+          # If @pre_sampler is not enable, sending this metric would be misleading
+          span.clear_metric(SAMPLE_RATE_METRIC_KEY)
+        end
+      end
+    end
+
+    def assign_priority!(span, priority)
+      if span.context
+        span.context.sampling_priority = priority
+      else
+        # Set the priority directly on the span instead, since otherwise
+        # it won't receive the appropriate tag.
+        span.set_metric(
+          Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
+          priority
+        )
+      end
+    end
+  end
+end