ddtrace 0.12.0 → 0.13.0

data/lib/ddtrace/contrib/sequel/dataset.rb

@@ -0,0 +1,59 @@
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sequel/utils'
+
+module Datadog
+  module Contrib
+    module Sequel
+      # Adds instrumentation to Sequel::Dataset
+      module Dataset
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Instance methods for instrumenting Sequel::Dataset
+        module InstanceMethods
+          def execute(sql, options = ::Sequel::OPTS, &block)
+            trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+          end
+
+          def execute_ddl(sql, options = ::Sequel::OPTS, &block)
+            trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+          end
+
+          def execute_dui(sql, options = ::Sequel::OPTS, &block)
+            trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+          end
+
+          def execute_insert(sql, options = ::Sequel::OPTS, &block)
+            trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+          end
+
+          def datadog_pin
+            Datadog::Pin.get_from(db)
+          end
+
+          private
+
+          def trace_execute(super_method, sql, options, &block)
+            opts = Utils.parse_opts(sql, options, db.opts)
+            response = nil
+
+            datadog_pin.tracer.trace('sequel.query') do |span|
+              span.service = datadog_pin.service
+              span.resource = opts[:query]
+              span.span_type = Datadog::Ext::SQL::TYPE
+              span.set_tag('sequel.db.vendor', adapter_name)
+              response = super_method.call(sql, options, &block)
+            end
+            response
+          end
+
+          def adapter_name
+            Utils.adapter_name(db)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'ddtrace/contrib/sequel/database'
+require 'ddtrace/contrib/sequel/dataset'
+
+module Datadog
+  module Contrib
+    module Sequel
+      # Patcher enables patching of 'sequel' module.
+      # This is used in monkey.rb to manually apply patches
+      module Patcher
+        include Base
+
+        APP = 'sequel'.freeze
+
+        register_as :sequel, auto_patch: false
+        option :service_name
+        option :tracer, default: Datadog.tracer
+
+        @patched = false
+
+        module_function
+
+        # patched? tells whether patch has been successfully applied
+        def patched?
+          @patched
+        end
+
+        def patch
+          if !@patched && compatible?
+            begin
+              patch_sequel_database
+              patch_sequel_dataset
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Sequel integration: #{e}")
+            end
+          end
+
+          @patched
+        end
+
+        def compatible?
+          RUBY_VERSION >= '2.0.0' && defined?(::Sequel)
+        end
+
+        def patch_sequel_database
+          ::Sequel::Database.send(:include, Database)
+        end
+
+        def patch_sequel_dataset
+          ::Sequel::Dataset.send(:include, Dataset)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sequel/utils.rb

@@ -0,0 +1,28 @@
+module Datadog
+  module Contrib
+    module Sequel
+      # General purpose functions for Sequel
+      module Utils
+        module_function
+
+        def adapter_name(database)
+          Datadog::Utils::Database.normalize_vendor(database.adapter_scheme.to_s)
+        end
+
+        def parse_opts(sql, opts, db_opts)
+          if ::Sequel::VERSION >= '4.37.0' && !sql.is_a?(String)
+            # In 4.37.0, sql was converted to a prepared statement object
+            sql = sql.prepared_sql unless sql.is_a?(Symbol)
+          end
+
+          {
+            name: opts[:type],
+            query: sql,
+            database: db_opts[:database],
+            host: db_opts[:host]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sidekiq/tracer.rb

@@ -32,6 +32,7 @@ module Datadog
             span.set_tag('sidekiq.job.retry', job['retry'])
             span.set_tag('sidekiq.job.queue', job['queue'])
             span.set_tag('sidekiq.job.wrapper', job['class']) if job['wrapped']
+            span.set_tag('sidekiq.job.delay', 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
 
             yield
           end

data/lib/ddtrace/contrib/sinatra/env.rb

@@ -0,0 +1,39 @@
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Gets and sets trace information from a Rack Env
+      module Env
+        ENV_SPAN = 'datadog.sinatra_request_span'.freeze
+
+        module_function
+
+        def datadog_span(env)
+          env[ENV_SPAN]
+        end
+
+        def set_datadog_span(env, span)
+          env[ENV_SPAN] = span
+        end
+
+        def request_header_tags(env, headers)
+          headers ||= []
+
+          {}.tap do |result|
+            headers.each do |header|
+              rack_header = header_to_rack_header(header)
+              if env.key?(rack_header)
+                result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
+              end
+            end
+          end
+        end
+
+        def header_to_rack_header(name)
+          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sinatra/headers.rb

@@ -0,0 +1,31 @@
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Gets and sets trace information from a Rack headers Hash
+      module Headers
+        module_function
+
+        def response_header_tags(headers, target_headers)
+          target_headers ||= []
+
+          {}.tap do |result|
+            target_headers.each do |header|
+              if headers.key?(header)
+                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
+              else
+                # Try a case-insensitive lookup
+                uppercased_header = header.to_s.upcase
+                matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
+                if matching_header
+                  result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -1,4 +1,3 @@
-
 require 'sinatra/base'
 
 require 'ddtrace/ext/app_types'
@@ -6,11 +5,14 @@ require 'ddtrace/ext/errors'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
 
+require 'ddtrace/contrib/sinatra/tracer_middleware'
+require 'ddtrace/contrib/sinatra/env'
+
 sinatra_vs = Gem::Version.new(Sinatra::VERSION)
 sinatra_min_vs = Gem::Version.new('1.4.0')
 if sinatra_vs < sinatra_min_vs
   raise "sinatra version #{sinatra_vs} is not supported yet " \
-        + "(supporting versions >=#{sinatra_min_vs})"
+          + "(supporting versions >=#{sinatra_min_vs})"
 end
 
 Datadog::Tracer.log.info("activating instrumentation for sinatra #{sinatra_vs}")
@@ -21,6 +23,10 @@ module Datadog
       # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
       # requests.
       module Tracer
+        DEFAULT_HEADERS = {
+          response: %w[Content-Type X-Request-ID]
+        }.freeze
+
         include Base
         register_as :sinatra
 
@@ -32,6 +38,7 @@ module Datadog
         option :tracer, default: Datadog.tracer
         option :resource_script_names, default: false
         option :distributed_tracing, default: false
+        option :headers, default: DEFAULT_HEADERS
 
         def route(verb, action, *)
           # Keep track of the route name when the app is instantiated for an
@@ -49,8 +56,6 @@ module Datadog
           super
         end
 
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
         def self.registered(app)
           ::Sinatra::Base.module_eval do
             def render(engine, data, *)
@@ -71,52 +76,30 @@ module Datadog
             end
           end
 
+          app.use TracerMiddleware
+
           app.before do
             return unless Datadog.configuration[:sinatra][:tracer].enabled
 
-            if instance_variable_defined? :@datadog_request_span
-              if @datadog_request_span
-                Datadog::Tracer.log.error('request span active in :before hook')
-                @datadog_request_span.finish()
-                @datadog_request_span = nil
-              end
-            end
-
-            tracer = Datadog.configuration[:sinatra][:tracer]
-            distributed_tracing = Datadog.configuration[:sinatra][:distributed_tracing]
-
-            if distributed_tracing && tracer.provider.context.trace_id.nil?
-              context = HTTPPropagator.extract(request.env)
-              tracer.provider.context = context if context.trace_id
-            end
-
-            span = tracer.trace('sinatra.request',
-                                service: Datadog.configuration[:sinatra][:service_name],
-                                span_type: Datadog::Ext::HTTP::TYPE)
+            span = Sinatra::Env.datadog_span(env)
             span.set_tag(Datadog::Ext::HTTP::URL, request.path)
             span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
-
-            @datadog_request_span = span
           end
 
           app.after do
             return unless Datadog.configuration[:sinatra][:tracer].enabled
 
-            span = @datadog_request_span
-            begin
-              unless span
-                Datadog::Tracer.log.error('missing request span in :after hook')
-                return
-              end
+            span = Sinatra::Env.datadog_span(env)
 
-              span.resource = "#{request.request_method} #{@datadog_route}"
-              span.set_tag('sinatra.route.path', @datadog_route)
-              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-              span.set_error(env['sinatra.error']) if response.server_error?
-              span.finish()
-            ensure
-              @datadog_request_span = nil
+            unless span
+              Datadog::Tracer.log.error('missing request span in :after hook')
+              return
             end
+
+            span.resource = "#{request.request_method} #{@datadog_route}"
+            span.set_tag('sinatra.route.path', @datadog_route)
+            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+            span.set_error(env['sinatra.error']) if response.server_error?
           end
         end
       end

data/lib/ddtrace/contrib/sinatra/tracer_middleware.rb

@@ -0,0 +1,61 @@
+require 'ddtrace/contrib/sinatra/env'
+require 'ddtrace/contrib/sinatra/headers'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Middleware used for automatically tagging configured headers and handle request span
+      class TracerMiddleware
+        REQUEST_TRACE_NAME = 'sinatra.request'.freeze
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          # Set the trace context (e.g. distributed tracing)
+          if configuration[:distributed_tracing] && tracer.provider.context.trace_id.nil?
+            context = HTTPPropagator.extract(env)
+            tracer.provider.context = context if context.trace_id
+          end
+
+          # Begin the trace
+          tracer.trace(
+            REQUEST_TRACE_NAME,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::HTTP::TYPE
+          ) do |span|
+            Sinatra::Env.set_datadog_span(env, span)
+
+            Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
+              span.set_tag(name, value) if span.get_tag(name).nil?
+            end
+
+            # Run application stack
+            status, headers, response_body = @app.call(env)
+
+            Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+              span.set_tag(name, value) if span.get_tag(name).nil?
+            end
+
+            [status, headers, response_body]
+          end
+        end
+
+        private
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def configuration
+          Datadog.configuration[:sinatra]
+        end
+
+        def header_to_rack_header(name)
+          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/ext/distributed.rb

@@ -7,6 +7,11 @@ module Datadog
       HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
       HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
       SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'.freeze
+
+      # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
+      GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'.freeze
+      GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'.freeze
+      GRPC_METADATA_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
     end
   end
 end

data/lib/ddtrace/ext/grpc.rb

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

data/lib/ddtrace/ext/http.rb

@@ -1,14 +1,44 @@
 module Datadog
   module Ext
     module HTTP
-      TYPE = 'http'.freeze
-      TEMPLATE = 'template'.freeze
-      URL = 'http.url'.freeze
       BASE_URL = 'http.base_url'.freeze
+      ERROR_RANGE = 500...600
       METHOD = 'http.method'.freeze
-      REQUEST_ID = 'http.request_id'.freeze
       STATUS_CODE = 'http.status_code'.freeze
-      ERROR_RANGE = 500...600
+      TEMPLATE = 'template'.freeze
+      TYPE = 'http'.freeze
+      URL = 'http.url'.freeze
+
+      # General header functionality
+      module Headers
+        module_function
+
+        def to_tag(name)
+          name.to_s.downcase.gsub(/[-\s]/, '_')
+        end
+      end
+
+      # Request headers
+      module RequestHeaders
+        PREFIX = 'http.request.headers'.freeze
+
+        module_function
+
+        def to_tag(name)
+          "#{PREFIX}.#{Headers.to_tag(name)}"
+        end
+      end
+
+      # Response headers
+      module ResponseHeaders
+        PREFIX = 'http.response.headers'.freeze
+
+        module_function
+
+        def to_tag(name)
+          "#{PREFIX}.#{Headers.to_tag(name)}"
+        end
+      end
     end
   end
 end

data/lib/ddtrace/propagation/grpc_propagator.rb

@@ -0,0 +1,54 @@
+require 'ddtrace/context'
+require 'ddtrace/ext/distributed'
+
+module Datadog
+  # opentracing.io compliant methods for distributing trace context
+  # between two or more distributed services. Note this is very close
+  # to the HTTPPropagator; the key difference is the way gRPC handles
+  # header information (called "metadata") as it operates over HTTP2
+  module GRPCPropagator
+    include Ext::DistributedTracing
+
+    def self.inject!(context, metadata)
+      metadata[GRPC_METADATA_TRACE_ID] = context.trace_id.to_s
+      metadata[GRPC_METADATA_PARENT_ID] = context.span_id.to_s
+      metadata[GRPC_METADATA_SAMPLING_PRIORITY] = context.sampling_priority.to_s if context.sampling_priority
+    end
+
+    def self.extract(metadata)
+      metadata = Carrier.new(metadata)
+      return Datadog::Context.new unless metadata.valid?
+      Datadog::Context.new(trace_id: metadata.trace_id,
+                           span_id: metadata.parent_id,
+                           sampling_priority: metadata.sampling_priority)
+    end
+
+    # opentracing.io compliant carrier object
+    class Carrier
+      include Ext::DistributedTracing
+
+      def initialize(metadata = {})
+        @metadata = metadata || {}
+      end
+
+      def valid?
+        trace_id && parent_id
+      end
+
+      def trace_id
+        value = @metadata[GRPC_METADATA_TRACE_ID].to_i
+        value if (1..Span::MAX_ID).cover? value
+      end
+
+      def parent_id
+        value = @metadata[GRPC_METADATA_PARENT_ID].to_i
+        value if (1..Span::MAX_ID).cover? value
+      end
+
+      def sampling_priority
+        value = @metadata[GRPC_METADATA_SAMPLING_PRIORITY]
+        value && value.to_i
+      end
+    end
+  end
+end

data/lib/ddtrace/quantization/hash.rb

@@ -0,0 +1,103 @@
+module Datadog
+  module Quantization
+    # Quantization for HTTP resources
+    module Hash
+      PLACEHOLDER = '?'.freeze
+      EXCLUDE_KEYS = [].freeze
+      SHOW_KEYS = [].freeze
+      DEFAULT_OPTIONS = {
+        exclude: EXCLUDE_KEYS,
+        show: SHOW_KEYS,
+        placeholder: PLACEHOLDER
+      }.freeze
+
+      module_function
+
+      def format(hash_obj, options = {})
+        options ||= {}
+        format!(hash_obj, options)
+      rescue StandardError
+        options[:placeholder] || PLACEHOLDER
+      end
+
+      def format!(hash_obj, options = {})
+        options ||= {}
+        options = merge_options(DEFAULT_OPTIONS, options)
+        format_hash(hash_obj, options)
+      end
+
+      def format_hash(hash_obj, options = {})
+        case hash_obj
+        when ::Hash
+          return {} if options[:exclude] == :all
+          return hash_obj if options[:show] == :all
+
+          hash_obj.each_with_object({}) do |(key, value), quantized|
+            if options[:show].any?(&indifferent_equals(key))
+              quantized[key] = value
+            elsif options[:exclude].none?(&indifferent_equals(key))
+              quantized[key] = format_value(value, options)
+            end
+          end
+        else
+          format_value(hash_obj, options)
+        end
+      end
+
+      def format_value(value, options = {})
+        return value if options[:show] == :all
+
+        case value
+        when ::Hash
+          format_hash(value, options)
+        when Array
+          # If any are objects, format them.
+          format_array(value, options)
+        else
+          options[:placeholder]
+        end
+      end
+
+      def format_array(value, options)
+        if value.any? { |v| v.class <= ::Hash || v.class <= Array }
+          first_entry = format_value(value.first, options)
+          value.size > 1 ? [first_entry, options[:placeholder]] : [first_entry]
+          # Otherwise short-circuit and return single placeholder
+        else
+          [options[:placeholder]]
+        end
+      end
+
+      def merge_options(original, additional)
+        {}.tap do |options|
+          # Show
+          # If either is :all, value becomes :all
+          options[:show] = if original[:show] == :all || additional[:show] == :all
+                             :all
+                           else
+                             (original[:show] || []).dup.concat(additional[:show] || []).uniq
+                           end
+
+          # Exclude
+          # If either is :all, value becomes :all
+          options[:exclude] = if original[:exclude] == :all || additional[:exclude] == :all
+                                :all
+                              else
+                                (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
+                              end
+
+          options[:placeholder] = additional[:placeholder] || original[:placeholder]
+        end
+      end
+
+      def indifferent_equals(value)
+        value = convert_value(value)
+        ->(compared_value) { value == convert_value(compared_value) }
+      end
+
+      def convert_value(value)
+        value.is_a?(Symbol) ? value.to_s : value
+      end
+    end
+  end
+end

data/lib/ddtrace/tracer.rb

@@ -23,6 +23,8 @@ module Datadog
     attr_accessor :enabled, :writer
     attr_writer :default_service
 
+    ALLOWED_SPAN_OPTIONS = [:service, :resource, :span_type].freeze
+
     # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
     # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
     def self.log
@@ -204,12 +206,13 @@ module Datadog
     # * +tags+: extra tags which should be added to the span.
     def start_span(name, options = {})
       start_time = options.fetch(:start_time, Time.now.utc)
+
       tags = options.fetch(:tags, {})
 
       opts = options.select do |k, _v|
         # Filter options, we want no side effects with unexpected args.
         # Plus, this documents the code (Ruby 2 named args would be better but we're Ruby 1.9 compatible)
-        [:service, :resource, :span_type].include?(k)
+        ALLOWED_SPAN_OPTIONS.include?(k)
       end
 
       ctx, parent = guess_context_and_parent(options[:child_of])

data/lib/ddtrace/utils/database.rb

@@ -0,0 +1,21 @@
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Database
+      module_function
+
+      def normalize_vendor(vendor)
+        case vendor
+        when nil
+          'defaultdb'
+        when 'postgresql'
+          'postgres'
+        when 'sqlite3'
+          'sqlite'
+        else
+          vendor
+        end
+      end
+    end
+  end
+end