ddtrace 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c67b70da15b11329601d55d07a79c4a9ce28173a
-  data.tar.gz: 5758cdd918f573731673bd41c05a7f2e2d5d1fe2
+  metadata.gz: 4b696f89a64327a9095fce4fa8dfe75fd243f3cb
+  data.tar.gz: 38fd90000f89a2379882c0ea73c343f1b8f2fd29
 SHA512:
-  metadata.gz: 2ee13f333805a8cfadf6e6bd6a125f636f29ce8e26e5bc71be9abacedf15a81af3dfbafc724c97dad4694899272bf5bfd152ae2eefa533cf70093ab1c2b20566
-  data.tar.gz: 256cb5ae9b387ba0fbb02b091cb044de139e561e524f895433a16a4e27659a5962966cd3c65495bbe3d073c28d520c685f5f093c809f2f439c9929dde9ebdb7f
+  metadata.gz: '0999d891c779b691db6faf84a85096f6465aac6a612dbdbaf2b6dceaf2c9293efd562b8cdaeb6a8a430fcf49752299adab64f21ec734ceb315df080acae55b7d'
+  data.tar.gz: 51319812e767f73499185daf8bc81f9121fc021aa43eb146ed246fac998aa824da08f2255f55f1535f1992dc87bcfa9645e3f1e56af8961f6f17e95e40ee753b

data/.gitignore

@@ -45,9 +45,8 @@ build-iPhoneSimulator/
 
 # for a library or gem, you might want to ignore these files since the code is
 # intended to run in multiple environments; otherwise, check them in:
-# Gemfile.lock
-# .ruby-version
-# .ruby-gemset
+.ruby-version
+.ruby-gemset
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc

data/Appraisals

@@ -40,6 +40,7 @@ if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
       gem 'pg', '0.15.1', platform: :ruby
       gem 'activerecord-jdbcpostgresql-adapter', platform: :jruby
       gem 'redis-rails'
+      gem 'redis', '< 4.0'
     end
 
     if RUBY_VERSION < '2.2.2'

data/ddtrace.gemspec

@@ -39,5 +39,8 @@ EOS
   spec.add_development_dependency 'minitest', '= 5.10.1'
   spec.add_development_dependency 'appraisal', '~> 2.2'
   spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'webmock', '~> 2.0'
+  # locking transitive dependency of webmock
+  spec.add_development_dependency 'addressable',  '~> 2.4.0'
   spec.add_development_dependency 'redcarpet', '~> 3.4' if RUBY_PLATFORM != 'java'
 end

data/docs/GettingStarted.md

@@ -141,6 +141,10 @@ either ``sinatra`` or ``sinatra/base``:
     require 'ddtrace'
     require 'ddtrace/contrib/sinatra/tracer'
 
+    Datadog.configure do |c|
+      c.use :sinatra, service_name: 'my-app'
+    end
+
     get '/' do
       'Hello world!'
     end
@@ -149,18 +153,11 @@ The tracing extension will be automatically activated.
 
 #### Configure the tracer
 
-To modify the default configuration, use the ``settings.datadog_tracer.configure`` method. For example,
-to change the default service name and activate the debug mode:
-
-    configure do
-      settings.datadog_tracer.configure default_service: 'my-app', debug: true
-    end
-
 Available settings are:
 
 * ``enabled``: define if the ``tracer`` is enabled or not. If set to ``false``, the code is still instrumented
   but no spans are sent to the local trace agent.
-* ``default_service``: set the service name used when tracing application requests. Defaults to ``sinatra``
+* ``service_name``: set the service name used when tracing application requests. Defaults to ``sinatra``
 * ``tracer``: set the tracer to use. Usually you don't need to change that value
   unless you're already using a different initialized tracer somewhere else
 * ``debug``: set to ``true`` to enable debug logging.
@@ -719,6 +716,32 @@ overhead.
     sampler = Datadog::RateSampler.new(0.5) # sample 50% of the traces
     Datadog.tracer.configure(sampler: sampler)
 
+#### Priority sampling
+
+Priority sampling consists in deciding if a trace will be kept by using a priority attribute that will be propagated for distributed traces. Its value gives indication to the Agent and to the backend on how important the trace is.
+
+* 0: Don’t keep the trace.
+* 1: The sampler automatically decided to keep the trace.
+* 2: The user asked the keep the trace.
+
+For now, priority sampling is disabled by default. Enabling it ensures that your sampled distributed traces will be complete. To enable the priority sampling:
+
+```rb
+Datadog.tracer.configure(priority_sampling: true)
+```
+
+Once enabled, the sampler will automatically assign a priority of 0 or 1 to traces, depending on their service and volume.
+
+You can also set this priority manually to either drop a non-interesting trace or to keep an important one. For that, set the `context#sampling_priority` to 0 or 2. It has to be done before any context propagation (fork, RPC calls) to be effective:
+
+```rb
+# Indicate to not keep the trace
+span.context.sampling_priority = 0
+
+# Indicate to keep the trace
+span.context.sampling_priority = 2
+```
+
 ### Distributed Tracing
 
 To trace requests across hosts, the spans on the secondary hosts must be linked together by setting ``trace_id`` and ``parent_id``:

data/gemfiles/rails32_postgres_redis.gemfile

@@ -7,5 +7,6 @@ gem "rails", "3.2.22.5"
 gem "pg", "0.15.1", platform: :ruby
 gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
 gem "redis-rails"
+gem "redis", "< 4.0"
 
 gemspec path: "../"

data/lib/ddtrace.rb

@@ -1,12 +1,14 @@
-require 'ddtrace/monkey'
+require 'ddtrace/registry'
 require 'ddtrace/pin'
 require 'ddtrace/tracer'
 require 'ddtrace/error'
 require 'ddtrace/pipeline'
+require 'ddtrace/configuration'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
-  @tracer = Datadog::Tracer.new()
+  @tracer = Tracer.new
+  @registry = Registry.new
 
   # Default tracer that can be used as soon as +ddtrace+ is required:
   #
@@ -25,42 +27,26 @@ module Datadog
   def self.tracer
     @tracer
   end
-end
 
-# Datadog auto instrumentation for frameworks
-if defined?(Rails::VERSION)
-  if !ENV['DISABLE_DATADOG_RAILS']
-    if Rails::VERSION::MAJOR.to_i >= 3
-      require 'ddtrace/contrib/rails/framework'
-      require 'ddtrace/contrib/rails/middlewares'
+  def self.registry
+    @registry
+  end
 
-      module Datadog
-        # Railtie class initializes
-        class Railtie < Rails::Railtie
-          # add instrumentation middlewares
-          options = {}
-          config.app_middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware, options)
-          config.app_middleware.use(Datadog::Contrib::Rails::ExceptionMiddleware)
+  class << self
+    attr_writer :configuration
 
-          # auto instrument Rails and third party components after
-          # the framework initialization
-          config.after_initialize do |app|
-            Datadog::Contrib::Rails::Framework.configure(config: app.config)
-            Datadog::Contrib::Rails::Framework.auto_instrument()
-            Datadog::Contrib::Rails::Framework.auto_instrument_redis()
-            Datadog::Contrib::Rails::Framework.auto_instrument_grape()
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-            # override Rack Middleware configurations with Rails
-            options.update(::Rails.configuration.datadog_trace)
-          end
-        end
-      end
-    else
-      Datadog::Tracer.log.warn 'Detected a Rails version < 3.x.'\
-                               'This version is not supported yet and the'\
-                               'auto-instrumentation for core components will be disabled.'
+    def configure
+      yield(configuration)
     end
-  else
-    Datadog::Tracer.log.info 'Skipping Rails auto-instrumentation, DISABLE_DATADOG_RAILS is set.'
   end
 end
+
+# Monkey currently is responsible for loading all contributions, which in turn
+# rely on the registry defined above. We should make our code less dependent on
+# the load order, by letting things be lazily loaded while keeping
+# thread-safety.
+require 'ddtrace/monkey'

data/lib/ddtrace/buffer.rb

@@ -16,8 +16,8 @@ module Datadog
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
     # even if the buffer is full. In that case, a random trace is discarded.
     def push(trace)
-      return if @closed
       @mutex.synchronize do
+        return if @closed
         len = @traces.length
         if len < @max_size || @max_size <= 0
           @traces << trace
@@ -56,11 +56,5 @@ module Datadog
         @closed = true
       end
     end
-
-    def closed?
-      @mutex.synchronise do
-        return @closed
-      end
-    end
   end
 end

data/lib/ddtrace/configurable.rb

@@ -0,0 +1,77 @@
+module Datadog
+  InvalidOptionError = Class.new(StandardError)
+  # Configurable provides configuration methods for a given class/module
+  module Configurable
+    IDENTITY = ->(x) { x }
+
+    def self.included(base)
+      base.singleton_class.send(:include, ClassMethods)
+    end
+
+    # ClassMethods
+    module ClassMethods
+      def set_option(name, value)
+        __assert_valid!(name)
+
+        __options[name][:value] = __options[name][:setter].call(value)
+        __options[name][:set_flag] = true
+      end
+
+      def get_option(name)
+        __assert_valid!(name)
+
+        return __options[name][:default] unless __options[name][:set_flag]
+
+        __options[name][:value]
+      end
+
+      def to_h
+        __options.each_with_object({}) do |(key, _), hash|
+          hash[key] = get_option(key)
+        end
+      end
+
+      def reset_options!
+        __options.each do |name, meta|
+          set_option(name, meta[:default])
+        end
+      end
+
+      def sorted_options
+        Configuration::Resolver.new(__dependency_graph).call
+      end
+
+      private
+
+      def option(name, meta = {}, &block)
+        name = name.to_sym
+        meta[:setter] ||= (block || IDENTITY)
+        meta[:depends_on] ||= []
+        __options[name] = meta
+      end
+
+      def __options
+        @__options ||= {}
+      end
+
+      def __assert_valid!(name)
+        return if __options.key?(name)
+        raise(InvalidOptionError, "#{__pretty_name} doesn't have the option: #{name}")
+      end
+
+      def __pretty_name
+        entry = Datadog.registry.find { |el| el.klass == self }
+
+        return entry.name if entry
+
+        to_s
+      end
+
+      def __dependency_graph
+        __options.each_with_object({}) do |(name, meta), graph|
+          graph[name] = meta[:depends_on]
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration.rb

@@ -0,0 +1,35 @@
+require_relative 'configuration/proxy'
+require_relative 'configuration/resolver'
+
+module Datadog
+  # Configuration provides a unique access point for configurations
+  class Configuration
+    InvalidIntegrationError = Class.new(StandardError)
+
+    def initialize(options = {})
+      @registry = options.fetch(:registry, Datadog.registry)
+    end
+
+    def [](integration_name)
+      integration = fetch_integration(integration_name)
+      Proxy.new(integration)
+    end
+
+    def use(integration_name, options = {})
+      integration = fetch_integration(integration_name)
+
+      integration.sorted_options.each do |name|
+        integration.set_option(name, options[name]) if options.key?(name)
+      end
+
+      integration.patch if integration.respond_to?(:patch)
+    end
+
+    private
+
+    def fetch_integration(name)
+      @registry[name] ||
+        raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
+    end
+  end
+end

data/lib/ddtrace/configuration/proxy.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+
+module Datadog
+  class Configuration
+    # Proxy provides a hash-like interface for fetching/setting configurations
+    class Proxy
+      extend Forwardable
+
+      def initialize(integration)
+        @integration = integration
+      end
+
+      def [](param)
+        value = @integration.get_option(param)
+
+        return value.call if value.respond_to?(:call)
+
+        value
+      end
+
+      def []=(param, value)
+        @integration.set_option(param, value)
+      end
+
+      def_delegators :@integration, :to_h, :reset_options!
+      def_delegators :to_h, :to_hash, :merge
+    end
+  end
+end

data/lib/ddtrace/configuration/resolver.rb

@@ -0,0 +1,24 @@
+require 'tsort'
+
+module Datadog
+  class Configuration
+    # Resolver performs a topological sort over the dependency graph
+    class Resolver
+      include TSort
+
+      def initialize(dependency_graph = {})
+        @dependency_graph = dependency_graph
+      end
+
+      def tsort_each_node(&blk)
+        @dependency_graph.each_key(&blk)
+      end
+
+      def tsort_each_child(node, &blk)
+        @dependency_graph.fetch(node).each(&blk)
+      end
+
+      alias call tsort
+    end
+  end
+end

data/lib/ddtrace/context.rb

@@ -15,18 +15,45 @@ module Datadog
   # This data structure is thread-safe.
   class Context
     # Initialize a new thread-safe \Context.
-    def initialize
+    def initialize(options = {})
       @mutex = Mutex.new
-      reset
+      reset(options)
     end
 
-    def reset
+    def reset(options = {})
       @trace = []
-      @sampled = false
+      @parent_trace_id = options.fetch(:trace_id, nil)
+      @parent_span_id = options.fetch(:span_id, nil)
+      @sampled = options.fetch(:sampled, false)
+      @sampling_priority = options.fetch(:sampling_priority, nil)
       @finished_spans = 0
       @current_span = nil
     end
 
+    def trace_id
+      @mutex.synchronize do
+        @parent_trace_id
+      end
+    end
+
+    def span_id
+      @mutex.synchronize do
+        @parent_span_id
+      end
+    end
+
+    def sampling_priority
+      @mutex.synchronize do
+        @sampling_priority
+      end
+    end
+
+    def sampling_priority=(priority)
+      @mutex.synchronize do
+        @sampling_priority = priority
+      end
+    end
+
     # Return the last active span that corresponds to the last inserted
     # item in the trace list. This cannot be considered as the current active
     # span in asynchronous environments, because some spans can be closed
@@ -37,11 +64,21 @@ module Datadog
       end
     end
 
+    def set_current_span(span)
+      @current_span = span
+      if span
+        @parent_trace_id = span.trace_id
+        @parent_span_id = span.span_id
+        @sampled = span.sampled
+      else
+        @parent_span_id = nil
+      end
+    end
+
     # Add a span to the context trace list, keeping it as the last active span.
     def add_span(span)
       @mutex.synchronize do
-        @current_span = span
-        @sampled = span.sampled
+        set_current_span(span)
         @trace << span
         span.context = self
       end
@@ -55,7 +92,7 @@ module Datadog
         # Current span is only meaningful for linear tree-like traces,
         # in other cases, this is just broken and one should rely
         # on per-instrumentation code to retrieve handle parent/child relations.
-        @current_span = span.parent
+        set_current_span(span.parent)
         return if span.tracer.nil?
         return unless Datadog::Tracer.debug_logging
         if span.parent.nil? && !check_finished_spans
@@ -102,6 +139,8 @@ module Datadog
 
         trace = @trace
         sampled = @sampled
+        attach_sampling_priority if sampled && @sampling_priority
+
         reset
         return trace, sampled
       end
@@ -115,8 +154,17 @@ module Datadog
       end
     end
 
+    def attach_sampling_priority
+      @trace.first.set_metric(
+        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
+        @sampling_priority
+      )
+    end
+
     private :reset
     private :check_finished_spans
+    private :set_current_span
+    private :attach_sampling_priority
   end
 
   # ThreadLocalContext can be used as a tracer global reference to create