ls-trace 0.1.1

data/lib/ddtrace/runtime/cgroup.rb

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/runtime'
+
+module Datadog
+  module Runtime
+    # For control groups
+    module Cgroup
+      LINE_REGEX = /^(\d+):([^:]*):(.+)$/
+
+      Descriptor = Struct.new(
+        :id,
+        :groups,
+        :path,
+        :controllers
+      )
+
+      module_function
+
+      def descriptors(process = 'self')
+        [].tap do |descriptors|
+          begin
+            filepath = "/proc/#{process}/cgroup"
+
+            if File.exist?(filepath)
+              File.open("/proc/#{process}/cgroup").each do |line|
+                line = line.strip
+                descriptors << parse(line) unless line.empty?
+              end
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
+          end
+        end
+      end
+
+      def parse(line)
+        id, groups, path = line.scan(LINE_REGEX).first
+
+        Descriptor.new(id, groups, path).tap do |descriptor|
+          descriptor.controllers = groups.split(',') unless groups.nil?
+        end
+      end
+    end
+  end
+end

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::Tracer.log.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,93 @@
+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
+        @service_tags = nil
+      end
+
+      def associate_with_span(span)
+        return if 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 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|
+            ["#{Ext::Runtime::Metrics::METRIC_GC_PREFIX}.#{k}", v]
+          end
+        ]
+      end
+
+      def try_flush
+        yield
+      rescue StandardError => e
+        Datadog::Tracer.log.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,195 @@
+require 'forwardable'
+
+require 'ddtrace/ext/priority'
+
+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
+  end
+
+  # \AllSampler samples all the traces.
+  class AllSampler < Sampler
+    def sample?(span)
+      true
+    end
+
+    def sample!(span)
+      span.sampled = true
+    end
+  end
+
+  # \RateSampler is based on a sample rate.
+  class RateSampler < Sampler
+    KNUTH_FACTOR = 1111111111111111111
+    SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
+
+    attr_reader :sample_rate
+
+    # 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::Tracer.log.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)
+      @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
+
+  # \RateByServiceSampler samples different services at different rates
+  class RateByServiceSampler < Sampler
+    DEFAULT_KEY = 'service:,env:'.freeze
+
+    def initialize(rate = 1.0, opts = {})
+      @env = opts.fetch(:env, Datadog.tracer.tags[:env])
+      @mutex = Mutex.new
+      @fallback = RateSampler.new(rate)
+      @sampler = { DEFAULT_KEY => @fallback }
+    end
+
+    def sample?(span)
+      key = key_for(span)
+
+      @mutex.synchronize do
+        @sampler.fetch(key, @fallback).sample?(span)
+      end
+    end
+
+    def sample!(span)
+      key = key_for(span)
+
+      @mutex.synchronize do
+        @sampler.fetch(key, @fallback).sample!(span)
+      end
+    end
+
+    def sample_rate(span)
+      key = key_for(span)
+
+      @mutex.synchronize do
+        @sampler.fetch(key, @fallback).sample_rate
+      end
+    end
+
+    def update(rate_by_service)
+      @mutex.synchronize do
+        @sampler.delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
+
+        rate_by_service.each do |key, rate|
+          @sampler[key] ||= RateSampler.new(rate)
+          @sampler[key].sample_rate = rate
+        end
+      end
+    end
+
+    private
+
+    def key_for(span)
+      "service:#{span.service},env:#{@env}"
+    end
+  end
+
+  # \PrioritySampler
+  class PrioritySampler
+    extend Forwardable
+
+    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.
+          # 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.
+          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)
+      @priority_sampler.sample?(span)
+    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