fair-ddtrace 0.8.2.a

data/lib/ddtrace/distributed.rb

@@ -0,0 +1,38 @@
+require 'ddtrace/span'
+
+module Datadog
+  # Common code related to distributed tracing.
+  module Distributed
+    module_function
+
+    # Parses a trace_id and a parent_id, typically sent as headers in
+    # a distributed tracing context, and returns a couple of trace_id,parent_id
+    # which are garanteed to be both non-zero. This does not 100% ensure they
+    # are valid (after all, the caller could mess up data) but at least it
+    # sorts out most common errors, such as syntax, nil values, etc.
+    # Both headers must be set, else nil values are returned, for both.
+    # Reports problem on debug log.
+    def parse_trace_headers(trace_id_header, parent_id_header)
+      return nil, nil if trace_id_header.nil? || parent_id_header.nil?
+      trace_id = trace_id_header.to_i
+      parent_id = parent_id_header.to_i
+      if trace_id.zero?
+        Datadog::Tracer.log.debug("invalid trace_id header: #{trace_id_header}")
+        return nil, nil
+      end
+      if parent_id.zero?
+        Datadog::Tracer.log.debug("invalid parent_id header: #{parent_id_header}")
+        return nil, nil
+      end
+      if trace_id < 0 || trace_id >= Datadog::Span::MAX_ID
+        Datadog::Tracer.log.debug("trace_id out of range: #{trace_id_header}")
+        return nil, nil
+      end
+      if parent_id < 0 || parent_id >= Datadog::Span::MAX_ID
+        Datadog::Tracer.log.debug("parent_id out of range: #{parent_id_header}")
+        return nil, nil
+      end
+      [trace_id, parent_id]
+    end
+  end
+end

data/lib/ddtrace/encoding.rb

@@ -0,0 +1,65 @@
+require 'json'
+require 'msgpack'
+
+module Datadog
+  # Encoding module that encodes data for the AgentTransport
+  module Encoding
+    # Encoder interface that provides the logic to encode traces and service
+    class Encoder
+      attr_reader :content_type
+
+      # When extending the ``Encoder`` class, ``content_type`` must be set because
+      # they're used by the HTTPTransport so that it should not need to know what is
+      # the right header to suggest the decoding format to the agent
+      def initialize
+        @content_type = ''
+      end
+
+      # Encodes a list of traces, expecting a list of items where each items
+      # is a list of spans. Before dump the string in a serialized format all
+      # traces are normalized. The traces nesting is not changed.
+      def encode_traces(traces)
+        to_send = []
+        traces.each do |trace|
+          to_send << trace.map(&:to_hash)
+        end
+        encode(to_send)
+      end
+
+      # Encodes services hash
+      def encode_services(services)
+        encode(services)
+      end
+
+      # Defines the underlying format used during traces or services encoding.
+      # This method must be implemented and should only be used by the internal functions.
+      def encode(_)
+        raise NotImplementedError
+      end
+    end
+
+    # Encoder for the JSON format
+    class JSONEncoder < Encoder
+      def initialize
+        Datadog::Tracer.log.debug('using JSON encoder; application performance may be degraded')
+        @content_type = 'application/json'
+      end
+
+      def encode(obj)
+        JSON.dump(obj)
+      end
+    end
+
+    # Encoder for the Msgpack format
+    class MsgpackEncoder < Encoder
+      def initialize
+        Datadog::Tracer.log.debug('using Msgpack encoder')
+        @content_type = 'application/msgpack'
+      end
+
+      def encode(obj)
+        MessagePack.pack(obj)
+      end
+    end
+  end
+end

data/lib/ddtrace/error.rb

@@ -0,0 +1,37 @@
+# Datadog global namespace
+module Datadog
+  # Error is a value-object responsible for sanitizing/encapsulating error data
+  class Error
+    attr_reader :type, :message, :backtrace
+
+    def self.build_from(value)
+      case value
+      when Error then value
+      when Array then new(*value)
+      when Exception then new(value.class, value.message, value.backtrace)
+      when ContainsMessage then new(value.class, value.message)
+      else BlankError
+      end
+    end
+
+    def initialize(type = nil, message = nil, backtrace = nil)
+      backtrace = Array(backtrace).join("\n")
+      @type = sanitize(type)
+      @message = sanitize(message)
+      @backtrace = sanitize(backtrace)
+    end
+
+    private
+
+    def sanitize(value)
+      value = value.to_s
+
+      return value if value.encoding == ::Encoding::UTF_8
+
+      value.encode(::Encoding::UTF_8)
+    end
+
+    BlankError = Error.new
+    ContainsMessage = ->(v) { v.respond_to?(:message) }
+  end
+end

data/lib/ddtrace/ext/app_types.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module AppTypes
+      WEB = 'web'.freeze
+      DB = 'db'.freeze
+      CACHE = 'cache'.freeze
+      WORKER = 'worker'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/cache.rb

@@ -0,0 +1,7 @@
+module Datadog
+  module Ext
+    module CACHE
+      TYPE = 'cache'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/distributed.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module DistributedTracing
+      # HTTP headers one should set for distributed tracing.
+      # These are cross-language (eg: Python, Go and other implementations should honor these)
+      HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
+      HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/errors.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module Ext
+    module Errors
+      STATUS = 1
+      MSG = 'error.msg'.freeze
+      TYPE = 'error.type'.freeze
+      STACK = 'error.stack'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/http.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module HTTP
+      TYPE = 'http'.freeze
+      TEMPLATE = 'template'.freeze
+      URL = 'http.url'.freeze
+      METHOD = 'http.method'.freeze
+      STATUS_CODE = 'http.status_code'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/net.rb

@@ -0,0 +1,8 @@
+module Datadog
+  module Ext
+    module NET
+      TARGET_HOST = 'out.host'.freeze
+      TARGET_PORT = 'out.port'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/redis.rb

@@ -0,0 +1,11 @@
+module Datadog
+  module Ext
+    module Redis
+      # type of the spans
+      TYPE = 'redis'.freeze
+
+      # net extension
+      DB = 'out.redis_db'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/sql.rb

@@ -0,0 +1,8 @@
+module Datadog
+  module Ext
+    module SQL
+      TYPE = 'sql'.freeze
+      QUERY = 'sql.query'.freeze
+    end
+  end
+end

data/lib/ddtrace/logger.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Datadog
+  LOG_PREFIX = 'ddtrace'.freeze
+
+  # A custom logger with minor enhancements:
+  # - progname defaults to ddtrace to clearly identify Datadog dd-trace-rb related messages
+  # - adds last caller stack-trace info to know where the message comes from
+  class Logger < ::Logger
+    def initialize(*args, &block)
+      super
+      self.progname = LOG_PREFIX
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      where = ''
+
+      # We are in debug mode, or this is an error, add stack trace to help debugging
+      if debug? || severity >= ::Logger::ERROR
+        c = caller
+        where = "(#{c[1]}) " if c.length > 1
+      end
+
+      if message.nil?
+        if block_given?
+          super(severity, message, progname) do
+            "[#{self.progname}] #{where}#{yield}"
+          end
+        else
+          super(severity, message, "[#{self.progname}] #{where}#{progname}")
+        end
+      else
+        super(severity, "[#{self.progname}] #{where}#{message}")
+      end
+    end
+
+    alias log add
+  end
+end

data/lib/ddtrace/monkey.rb

@@ -0,0 +1,84 @@
+require 'thread'
+
+# We import all patchers for every module we support, but this is fine
+# because patchers do not include any 3rd party module nor even our
+# patching code, which is required on demand, when patching.
+require 'ddtrace/contrib/active_record/patcher'
+require 'ddtrace/contrib/elasticsearch/patcher'
+require 'ddtrace/contrib/grape/patcher'
+require 'ddtrace/contrib/redis/patcher'
+require 'ddtrace/contrib/http/patcher'
+
+module Datadog
+  # Monkey is used for monkey-patching 3rd party libs.
+  module Monkey
+    @patched = []
+    @autopatch_modules = {
+      elasticsearch: true,
+      http: true,
+      redis: true,
+      grape: true,
+      active_record: false
+    }
+    # Patchers should expose 2 methods:
+    # - patch, which applies our patch if needed. Should be idempotent,
+    #   can be call twice but should just do nothing the second time.
+    # - patched?, which returns true if the module has been succesfully
+    #   patched (patching might have failed if requirements were not here)
+    @patchers = { elasticsearch: Datadog::Contrib::Elasticsearch::Patcher,
+                  http: Datadog::Contrib::HTTP::Patcher,
+                  redis: Datadog::Contrib::Redis::Patcher,
+                  grape: Datadog::Contrib::Grape::Patcher,
+                  active_record: Datadog::Contrib::ActiveRecord::Patcher }
+    @mutex = Mutex.new
+
+    module_function
+
+    def autopatch_modules
+      @autopatch_modules.clone
+    end
+
+    def patch_all
+      patch @autopatch_modules
+    end
+
+    def patch_module(m)
+      @mutex.synchronize do
+        patcher = @patchers[m]
+        raise "Unsupported module #{m}" unless patcher
+        patcher.patch
+      end
+    end
+
+    def patch(modules)
+      modules.each do |k, v|
+        patch_module(k) if v
+      end
+    end
+
+    def get_patched_modules
+      patched = autopatch_modules
+      @patchers.each do |k, v|
+        @mutex.synchronize do
+          if v
+            patcher = @patchers[k]
+            patched[k] = patcher.patched? if patcher
+          end
+        end
+      end
+      patched
+    end
+
+    def 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
+  end
+end

data/lib/ddtrace/pin.rb

@@ -0,0 +1,63 @@
+# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
+module Datadog
+  # A \Pin (a.k.a Patch INfo) is a small class which is used to
+  # set tracing metadata on a particular traced object.
+  # This is useful if you wanted to, say, trace two different
+  # database clusters.
+  class Pin
+    def self.get_from(obj)
+      return nil unless obj.respond_to? :datadog_pin
+      obj.datadog_pin
+    end
+
+    attr_accessor :service
+    attr_accessor :app
+    attr_accessor :tags
+    attr_accessor :app_type
+    attr_accessor :name
+    attr_accessor :tracer
+    attr_accessor :config
+
+    # [ruby19] named parameters would be more idiomatic here, but would break backward compatibility
+    def initialize(service, options = { app: nil, tags: nil, app_type: nil, tracer: nil, config: nil })
+      @service = service
+      @app = options.fetch(:app, nil)
+      @tags = options.fetch(:tags, nil)
+      @app_type = options.fetch(:app_type, nil)
+      @name = nil # this would rarely be overriden as it's really span-specific
+      @tracer = options[:tracer] || Datadog.tracer
+      @config = options.fetch(:config, nil)
+    end
+
+    def enabled?
+      return @tracer.enabled if @tracer
+      false
+    end
+
+    def onto(obj)
+      unless obj.respond_to? :datadog_pin=
+        obj.instance_exec do
+          def datadog_pin=(pin)
+            Datadog::Tracer.log.debug("Set pin #{pin.service} on #{self.class}.")
+            @datadog_pin = pin
+          end
+        end
+      end
+
+      unless obj.respond_to? :datadog_pin
+        obj.instance_exec do
+          def datadog_pin
+            Datadog::Tracer.log.debug("Get pin from #{self.class}.")
+            @datadog_pin
+          end
+        end
+      end
+
+      obj.datadog_pin = self
+    end
+
+    def to_s
+      "Pin(service:#{@service},app:#{@app},app_type:#{@app_type},name:#{@name})"
+    end
+  end
+end

data/lib/ddtrace/provider.rb

@@ -0,0 +1,21 @@
+module Datadog
+  # DefaultContextProvider is a default context provider that retrieves
+  # all contexts from the current thread-local storage. It is suitable for
+  # synchronous programming.
+  class DefaultContextProvider
+    # Initializes the default context provider with a thread-bound context.
+    def initialize
+      @context = Datadog::ThreadLocalContext.new
+    end
+
+    # Sets the current context.
+    def context=(ctx)
+      @context.local = ctx
+    end
+
+    # Return the current context.
+    def context
+      @context.local
+    end
+  end
+end

data/lib/ddtrace/sampler.rb

@@ -0,0 +1,49 @@
+module Datadog
+  # \Sampler performs client-side trace sampling.
+  class Sampler
+    def sample(_span)
+      raise NotImplementedError, 'samplers have to implement the sample() method'
+    end
+  end
+
+  # \AllSampler samples all the traces.
+  class AllSampler < Sampler
+    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.sampled = ((span.trace_id * KNUTH_FACTOR) % Datadog::Span::MAX_ID) <= @sampling_id_threshold
+      span.set_metric(SAMPLE_RATE_METRIC_KEY, @sample_rate)
+    end
+  end
+end