ddtrace 0.12.1 → 0.13.0.beta1

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/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,89 @@
+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].include?(key.to_sym)
+              quantized[key] = value
+            elsif !options[:exclude].include?(key.to_sym)
+              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.
+          if value.any? { |v| v.class <= ::Hash || v.class <= Array }
+            value.collect { |i| format_value(i, options) }
+          # Otherwise short-circuit and return single placeholder
+          else
+            [options[:placeholder]]
+          end
+        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
+    end
+  end
+end

data/lib/ddtrace/tracer.rb

@@ -23,8 +23,6 @@ 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
@@ -206,13 +204,12 @@ 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)
-        ALLOWED_SPAN_OPTIONS.include?(k)
+        [:service, :resource, :span_type].include?(k)
       end
 
       ctx, parent = guess_context_and_parent(options[:child_of])

data/lib/ddtrace/utils.rb

@@ -1,3 +1,5 @@
+require 'ddtrace/utils/database'
+
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
   module Utils
@@ -26,20 +28,12 @@ module Datadog
 
     reset!
 
-    def self.truncate(value, size, omission = '...'.freeze)
+    def self.truncate(value, size, omission = '...')
       string = value.to_s
 
       return string if string.size <= size
 
-      string = string.slice(0, size - 1)
-
-      if size < omission.size
-        string[0, size] = omission
-      else
-        string[size - omission.size, size] = omission
-      end
-
-      string
+      string.slice(0, size - omission.size) + omission
     end
 
     def self.utf8_encode(str, options = {})

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

data/lib/ddtrace/version.rb

@@ -1,9 +1,9 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 12
-    PATCH = 1
-    PRE = nil
+    MINOR = 13
+    PATCH = 0
+    PRE = 'beta1'.freeze
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
   end