ddtrace 0.3.1

data/lib/ddtrace/contrib/redis/patcher.rb

@@ -0,0 +1,36 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    module Redis
+      # Patcher enables patching of 'redis' module.
+      # This is used in monkey.rb to automatically apply patches
+      module Patcher
+        @patched = false
+
+        module_function
+
+        # patch applies our patch if needed
+        def patch
+          if !@patched && (defined?(::Redis::VERSION) && \
+                           Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0'))
+            begin
+              require 'ddtrace/contrib/redis/core'
+              ::Redis.prepend Datadog::Contrib::Redis::TracedRedis
+              ::Redis::Client.prepend Datadog::Contrib::Redis::TracedRedisClient
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        # patched? tells wether patch has been successfully applied
+        def patched?
+          @patched
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/redis/quantize.rb

@@ -0,0 +1,30 @@
+module Datadog
+  module Contrib
+    module Redis
+      # Quantize contains Redis-specific resource quantization tools.
+      module Quantize
+        PLACEHOLDER = '?'.freeze
+        TOO_LONG_MARK = '...'.freeze
+        VALUE_MAX_LEN = 100
+        CMD_MAX_LEN = 1000
+
+        module_function
+
+        def format_arg(arg)
+          a = arg.to_s
+          a = a[0..(VALUE_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if a.length > VALUE_MAX_LEN
+          a
+        rescue StandardError => e
+          Datadog::Tracer.log.debug("non formattable Redis arg #{a}: #{e}")
+          PLACEHOLDER
+        end
+
+        def format_command_args(command_args)
+          cmd = command_args.map { |x| format_arg(x) }.join(' ')
+          cmd = cmd[0..(CMD_MAX_LEN - TOO_LONG_MARK.length - 1)] + TOO_LONG_MARK if cmd.length > CMD_MAX_LEN
+          cmd
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/redis/tags.rb

@@ -0,0 +1,19 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/redis'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Tags handles generic common tags assignment.
+      module Tags
+        module_function
+
+        def set_common_tags(client, span)
+          span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
+          span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
+          span.set_tag Datadog::Ext::Redis::DB, client.db
+        end
+      end
+    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/ext/app_types.rb

@@ -0,0 +1,9 @@
+module Datadog
+  module Ext
+    module AppTypes
+      WEB = 'web'.freeze
+      DB = 'db'.freeze
+      CACHE = 'cache'.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/errors.rb

@@ -0,0 +1,9 @@
+module Datadog
+  module Ext
+    module Errors
+      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,16 @@
+module Datadog
+  module Ext
+    module Redis
+      # type of the spans
+      TYPE = 'redis'.freeze
+
+      # net extension
+      DB = 'out.redis_db'.freeze
+
+      # standard tags
+      RAWCMD = 'redis.raw_command'.freeze
+      ARGS_LEN = 'redis.args_length'.freeze
+      PIPELINE_LEN = 'redis.pipeline_length'.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/monkey.rb

@@ -0,0 +1,60 @@
+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/elasticsearch/patcher'
+require 'ddtrace/contrib/redis/patcher'
+
+module Datadog
+  # Monkey is used for monkey-patching 3rd party libs.
+  module Monkey
+    @patched = []
+    @autopatch_modules = { elasticsearch: true, redis: true }
+    # 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,
+                  redis: Datadog::Contrib::Redis::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
+      @autopatch_modules.each do |k, v|
+        @mutex.synchronize do
+          if v
+            patcher = @patchers[k]
+            patched[k] = patcher.patched? if patcher
+          end
+        end
+      end
+      patched
+    end
+  end
+end

data/lib/ddtrace/pin.rb

@@ -0,0 +1,62 @@
+# \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
+
+    def initialize(service, app: nil, tags: nil, app_type: nil, tracer: Datadog.tracer)
+      @service = service
+      @app = app
+      @tags = tags
+      @app_type = app_type
+      @name = nil # this would rarely be overriden as it's really span-specific
+      @tracer = tracer
+    end
+
+    def enabled?
+      return @tracer.enabled if @tracer
+      false
+    end
+
+    def onto(obj)
+      # rubocop:disable Lint/NestedMethodDefinition
+      unless obj.respond_to? :datadog_pin=
+        obj.instance_exec do
+          def datadog_pin=(pin)
+            Datadog::Tracer.log.debug('Set pin #{pin.service} on #{obj.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 #{obj.class}.')
+            @datadog_pin
+          end
+        end
+      end
+      # rubocop:enable Lint/NestedMethodDefinition
+
+      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/span.rb

@@ -0,0 +1,163 @@
+require 'time'
+
+require 'ddtrace/utils'
+require 'ddtrace/ext/errors'
+
+module Datadog
+  # Represents a logical unit of work in the system. Each trace consists of one or more spans.
+  # Each span consists of a start time and a duration. For example, a span can describe the time
+  # spent on a distributed call on a separate machine, or the time spent in a small component
+  # within a larger operation. Spans can be nested within each other, and in those instances
+  # will have a parent-child relationship.
+  class Span
+    # The max value for a \Span identifier
+    MAX_ID = 2**64 - 1
+
+    attr_accessor :name, :service, :resource, :span_type,
+                  :start_time, :end_time,
+                  :span_id, :trace_id, :parent_id,
+                  :status, :parent
+
+    # Create a new span linked to the given tracer. Call the <tt>finish()</tt> method once the
+    # tracer operation is over or use the <tt>finish_at(time)</tt> helper to close the span with the
+    # given +time+. Available options are:
+    #
+    # * +service+: the service name for this span
+    # * +resource+: the resource this span refers, or +name+ if it's missing
+    # * +span_type+: the type of the span (such as +http+, +db+ and so on)
+    # * +parent_id+: the identifier of the parent span
+    # * +trace_id+: the identifier of the root span for this trace
+    def initialize(tracer, name, options = {})
+      @tracer = tracer
+
+      @name = name
+      @service = options.fetch(:service, nil)
+      @resource = options.fetch(:resource, name)
+      @span_type = options.fetch(:span_type, nil)
+
+      @span_id = Datadog::Utils.next_id()
+      @parent_id = options.fetch(:parent_id, 0)
+      @trace_id = options.fetch(:trace_id, @span_id)
+
+      @meta = {}
+      @status = 0
+
+      @parent = nil
+
+      @start_time = Time.now.utc
+      @end_time = nil
+    end
+
+    # Set the given key / value tag pair on the span. Keys and values
+    # must be strings. A valid example is:
+    #
+    #   span.set_tag('http.method', request.method)
+    def set_tag(key, value)
+      @meta[key] = value.to_s
+    rescue StandardError => e
+      Datadog::Tracer.log.error("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
+    end
+
+    # Return the tag wth the given key, nil if it doesn't exist.
+    def get_tag(key)
+      @meta[key]
+    end
+
+    # Mark the span with the given error.
+    def set_error(e)
+      return if e.nil?
+      @status = 1
+      @meta[Datadog::Ext::Errors::MSG] = e.message
+      @meta[Datadog::Ext::Errors::TYPE] = e.class.to_s
+      @meta[Datadog::Ext::Errors::STACK] = e.backtrace.join("\n")
+    end
+
+    # Mark the span finished at the current time and submit it.
+    def finish
+      finish_at(Time.now.utc)
+    end
+
+    # Mark the span finished at the given time and submit it.
+    def finish_at(end_time)
+      @end_time = end_time
+
+      @tracer.record(self) unless @tracer.nil?
+
+      self
+    end
+
+    # Return whether the span is finished or not.
+    def finished?
+      !@end_time.nil?
+    end
+
+    # Return a string representation of the span.
+    def to_s
+      "Span(name:#{@name},sid:#{@span_id},tid:#{@trace_id},pid:#{@parent_id})"
+    end
+
+    # Set this span's parent, inheriting any properties not explicitly set.
+    # If the parent is nil, set the span zero values.
+    def set_parent(parent)
+      @parent = parent
+
+      if parent.nil?
+        @trace_id = @span_id
+        @parent_id = 0
+      else
+        @trace_id = parent.trace_id
+        @parent_id = parent.span_id
+        @service ||= parent.service
+      end
+    end
+
+    # Return the hash representation of the current span.
+    def to_hash
+      h = {
+        span_id: @span_id,
+        parent_id: @parent_id,
+        trace_id: @trace_id,
+        name: @name,
+        service: @service,
+        resource: @resource,
+        type: @span_type,
+        meta: @meta,
+        error: @status
+      }
+
+      if !@start_time.nil? && !@end_time.nil?
+        h[:start] = (@start_time.to_f * 1e9).to_i
+        h[:duration] = ((@end_time - @start_time) * 1e9).to_i
+      end
+
+      h
+    end
+
+    # Return a human readable version of the span
+    def pretty_print(q)
+      start_time = (@start_time.to_f * 1e9).to_i rescue '-'
+      end_time = (@end_time.to_f * 1e9).to_i rescue '-'
+      duration = ((@end_time - @start_time) * 1e9).to_i rescue 0
+      q.group 0 do
+        q.breakable
+        q.text "Name: #{@name}\n"
+        q.text "Span ID: #{@span_id}\n"
+        q.text "Parent ID: #{@parent_id}\n"
+        q.text "Trace ID: #{@trace_id}\n"
+        q.text "Type: #{@span_type}\n"
+        q.text "Service: #{@service}\n"
+        q.text "Resource: #{@resource}\n"
+        q.text "Error: #{@status}\n"
+        q.text "Start: #{start_time}\n"
+        q.text "End: #{end_time}\n"
+        q.text "Duration: #{duration}\n"
+        q.group(2, 'Tags: [', ']') do
+          q.breakable
+          q.seplist @meta.each do |key, value|
+            q.text "#{key} => #{value}"
+          end
+        end
+      end
+    end
+  end
+end