ddtrace 0.28.0 → 0.29.0

data/Rakefile

@@ -54,7 +54,7 @@ namespace :spec do
 
   RSpec::Core::RakeTask.new(:contrib) do |t, args|
     # rubocop:disable Metrics/LineLength
-    t.pattern = 'spec/**/contrib/{analytics,configurable,integration,patchable,patcher,registerable,registry,configuration/*}_spec.rb'
+    t.pattern = 'spec/**/contrib/{analytics,configurable,extensions,integration,patchable,patcher,registerable,registry,configuration/*}_spec.rb'
     t.rspec_opts = args.to_a.join(' ')
   end
 
@@ -189,8 +189,8 @@ end
 
 desc 'CI task; it runs all tests for current version of Ruby'
 task :ci do
-  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
-    raise NotImplementedError, 'Ruby versions < 2.0.0 are not supported!'
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new(Datadog::VERSION::MINIMUM_RUBY_VERSION)
+    raise NotImplementedError, "Ruby versions < #{Datadog::VERSION::MINIMUM_RUBY_VERSION} are not supported!"
   elsif Gem::Version.new('2.0.0') <= Gem::Version.new(RUBY_VERSION) \
         && Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1.0')
     # Main library

data/ddtrace.gemspec

@@ -7,7 +7,7 @@ require 'ddtrace/version'
 Gem::Specification.new do |spec|
   spec.name                  = 'ddtrace'
   spec.version               = Datadog::VERSION::STRING
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = ">= #{Datadog::VERSION::MINIMUM_RUBY_VERSION}"
   spec.authors               = ['Datadog, Inc.']
   spec.email                 = ['dev@datadoghq.com']
 
@@ -58,4 +58,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'redcarpet', '~> 3.4' if RUBY_PLATFORM != 'java'
   spec.add_development_dependency 'pry', '~> 0.10.4'
   spec.add_development_dependency 'pry-stack_explorer', '~> 0.4.9.2'
+  spec.add_development_dependency 'warning' if RUBY_VERSION >= '2.5.0'
 end

data/docs/DevelopmentGuide.md

@@ -19,7 +19,7 @@ This guide covers some of the common how-tos and technical reference material fo
 
 The trace library uses Docker Compose to create a Ruby environment to develop and test within, as well as containers for any dependencies that might be necessary for certain kinds of tests.
 
-To start a development environment, choose a target Ruby version (e.g. between `1.9` and `2.4`) then run the following:
+To start a development environment, choose a target Ruby version then run the following:
 
 ```
 # In the root directory of the project...

data/docs/GettingStarted.md

@@ -324,11 +324,11 @@ For a list of available integrations, and their configuration options, please re
 
 | Name                     | Key                        | Versions Supported       | How to configure                    | Gem source                                                                     |
 | ------------------------ | -------------------------- | ------------------------ | ----------------------------------- | ------------------------------------------------------------------------------ |
-| Action View              | `action_view`              | `>= 3.2`          | *[Link](#action-view)*              | *[Link](https://github.com/rails/rails/tree/master/actionview)*                |
+| Action View              | `action_view`              | `>= 3.2`                 | *[Link](#action-view)*              | *[Link](https://github.com/rails/rails/tree/master/actionview)*                |
 | Active Model Serializers | `active_model_serializers` | `>= 0.9`                 | *[Link](#active-model-serializers)* | *[Link](https://github.com/rails-api/active_model_serializers)*                |
-| Action Pack              | `action_pack`              | `>= 3.2`          | *[Link](#action-pack)*              | *[Link](https://github.com/rails/rails/tree/master/actionpack)*                |
-| Active Record            | `active_record`            | `>= 3.2`          | *[Link](#active-record)*            | *[Link](https://github.com/rails/rails/tree/master/activerecord)*              |
-| Active Support           | `active_support`           | `>= 3.2`          | *[Link](#active-support)*           | *[Link](https://github.com/rails/rails/tree/master/activesupport)*             |
+| Action Pack              | `action_pack`              | `>= 3.2`                 | *[Link](#action-pack)*              | *[Link](https://github.com/rails/rails/tree/master/actionpack)*                |
+| Active Record            | `active_record`            | `>= 3.2`                 | *[Link](#active-record)*            | *[Link](https://github.com/rails/rails/tree/master/activerecord)*              |
+| Active Support           | `active_support`           | `>= 3.2`                 | *[Link](#active-support)*           | *[Link](https://github.com/rails/rails/tree/master/activesupport)*             |
 | AWS                      | `aws`                      | `>= 2.0`                 | *[Link](#aws)*                      | *[Link](https://github.com/aws/aws-sdk-ruby)*                                  |
 | Concurrent Ruby          | `concurrent_ruby`          | `>= 0.9`                 | *[Link](#concurrent-ruby)*          | *[Link](https://github.com/ruby-concurrency/concurrent-ruby)*                  |
 | Dalli                    | `dalli`                    | `>= 2.7`                 | *[Link](#dalli)*                    | *[Link](https://github.com/petergoldstein/dalli)*                              |
@@ -345,9 +345,9 @@ For a list of available integrations, and their configuration options, please re
 | Net/HTTP                 | `http`                     | *(Any supported Ruby)*   | *[Link](#nethttp)*                  | *[Link](https://ruby-doc.org/stdlib-2.4.0/libdoc/net/http/rdoc/Net/HTTP.html)* |
 | Racecar                  | `racecar`                  | `>= 0.3.5`               | *[Link](#racecar)*                  | *[Link](https://github.com/zendesk/racecar)*                                   |
 | Rack                     | `rack`                     | `>= 1.4.7`               | *[Link](#rack)*                     | *[Link](https://github.com/rack/rack)*                                         |
-| Rails                    | `rails`                    | `>= 3.2`         | *[Link](#rails)*                    | *[Link](https://github.com/rails/rails)*                                       |
+| Rails                    | `rails`                    | `>= 3.2`                 | *[Link](#rails)*                    | *[Link](https://github.com/rails/rails)*                                       |
 | Rake                     | `rake`                     | `>= 12.0`                | *[Link](#rake)*                     | *[Link](https://github.com/ruby/rake)*                                         |
-| Redis                    | `redis`                    | `>= 3.2, < 4.0`          | *[Link](#redis)*                    | *[Link](https://github.com/redis/redis-rb)*                                    |
+| Redis                    | `redis`                    | `>= 3.2`                 | *[Link](#redis)*                    | *[Link](https://github.com/redis/redis-rb)*                                    |
 | Resque                   | `resque`                   | `>= 1.0, < 2.0`          | *[Link](#resque)*                   | *[Link](https://github.com/resque/resque)*                                     |
 | Rest Client              | `rest-client`              | `>= 1.8`                 | *[Link](#rest-client)*              | *[Link](https://github.com/rest-client/rest-client)*                           |
 | Sequel                   | `sequel`                   | `>= 3.41`                | *[Link](#sequel)*                   | *[Link](https://github.com/jeremyevans/sequel)*                                |

data/lib/ddtrace.rb

@@ -1,5 +1,12 @@
 require 'thread'
 
+# During development, we load `ddtrace` by through `ddtrace.gemspec`,
+# which in turn eager loads 'ddtrace/version'.
+#
+# Users load this gem by requiring this file.
+# We need to ensure that any files loaded in our gemspec are also loaded here.
+require 'ddtrace/version'
+
 require 'ddtrace/pin'
 require 'ddtrace/tracer'
 require 'ddtrace/error'

data/lib/ddtrace/buffer.rb

@@ -1,4 +1,6 @@
 require 'thread'
+require 'ddtrace/diagnostics/health'
+require 'ddtrace/runtime/object_space'
 
 module Datadog
   # Trace buffer that stores application traces. The buffer has a maximum size and when
@@ -11,6 +13,12 @@ module Datadog
       @mutex = Mutex.new()
       @traces = []
       @closed = false
+
+      # Initialize metric values
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
     end
 
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
@@ -23,8 +31,13 @@ module Datadog
           @traces << trace
         else
           # we should replace a random trace with the new one
-          @traces[rand(len)] = trace
+          replace_index = rand(len)
+          replaced_trace = @traces[replace_index]
+          @traces[replace_index] = trace
+          measure_drop(replaced_trace)
         end
+
+        measure_accept(trace)
       end
     end
 
@@ -47,6 +60,9 @@ module Datadog
       @mutex.synchronize do
         traces = @traces
         @traces = []
+
+        measure_pop(traces)
+
         return traces
       end
     end
@@ -56,5 +72,48 @@ module Datadog
         @closed = true
       end
     end
+
+    # Aggregate metrics:
+    # They reflect buffer activity since last #pop.
+    # These may not be as accurate or as granular, but they
+    # don't use as much network traffic as live stats.
+
+    def measure_accept(trace)
+      @buffer_spans += trace.length
+      @buffer_accepted += 1
+      @buffer_accepted_lengths += trace.length
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_drop(trace)
+      @buffer_dropped += 1
+      @buffer_spans -= trace.length
+      @buffer_accepted_lengths -= trace.length
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_pop(traces)
+      # Accepted
+      Diagnostics::Health.metrics.queue_accepted(@buffer_accepted)
+      Diagnostics::Health.metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+      # Dropped
+      Diagnostics::Health.metrics.queue_dropped(@buffer_dropped)
+
+      # Queue gauges
+      Diagnostics::Health.metrics.queue_max_length(@max_size)
+      Diagnostics::Health.metrics.queue_spans(@buffer_spans)
+      Diagnostics::Health.metrics.queue_length(traces.length)
+
+      # Reset aggregated metrics
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
   end
 end

data/lib/ddtrace/configuration/base.rb

@@ -0,0 +1,82 @@
+require 'ddtrace/environment'
+require 'ddtrace/configuration/options'
+
+module Datadog
+  module Configuration
+    # Basic configuration behavior
+    module Base
+      def self.included(base)
+        base.send(:extend, Datadog::Environment::Helpers)
+        base.send(:include, Options)
+
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for configuration
+      module ClassMethods
+        protected
+
+        # Allows subgroupings of settings to be defined.
+        # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
+        def settings(name, &block)
+          settings_class = new_settings_class(&block)
+
+          option(name) do |o|
+            o.default settings_class.new
+            o.resetter do |value|
+              value.reset! if value.respond_to?(:reset!)
+              value
+            end
+          end
+        end
+
+        private
+
+        def new_settings_class(&block)
+          Class.new { include Datadog::Configuration::Base }.tap do |klass|
+            klass.instance_eval(&block) if block_given?
+          end
+        end
+      end
+
+      # Instance methods for configuration
+      module InstanceMethods
+        def initialize(options = {})
+          configure(options)
+        end
+
+        def configure(opts = {})
+          # Sort the options in preference of dependency order first
+          ordering = self.class.options.dependency_order
+          sorted_opts = opts.sort_by do |name, _value|
+            ordering.index(name) || (ordering.length + 1)
+          end
+
+          # Ruby 2.0 doesn't support Array#to_h
+          sorted_opts = Hash[*sorted_opts.flatten]
+
+          # Apply options in sort order
+          sorted_opts.each do |name, value|
+            if respond_to?("#{name}=")
+              send("#{name}=", value)
+            elsif option_defined?(name)
+              set_option(name, value)
+            end
+          end
+
+          # Apply any additional settings from block
+          yield(self) if block_given?
+        end
+
+        def to_h
+          options_hash
+        end
+
+        def reset!
+          reset_options!
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/option.rb

@@ -13,19 +13,42 @@ module Datadog
       end
 
       def set(value)
-        @value = @context.instance_exec(value, &definition.setter).tap do
+        (@value = context_exec(value, &definition.setter)).tap do |v|
           @is_set = true
+          context_exec(v, &definition.on_set) if definition.on_set
         end
       end
 
       def get
-        return definition.default_value unless @is_set
-        @value
+        if @is_set
+          @value
+        elsif definition.delegate_to
+          context_eval(&definition.delegate_to)
+        else
+          set(definition.default_value)
+        end
       end
 
       def reset
-        @is_set = false
-        @value = nil
+        @value = if definition.resetter
+                   # Don't change @is_set to false; custom resetters are
+                   # responsible for changing @value back to a good state.
+                   # Setting @is_set = false would cause a default to be applied.
+                   context_exec(@value, &definition.resetter)
+                 else
+                   @is_set = false
+                   nil
+                 end
+      end
+
+      private
+
+      def context_exec(*args, &block)
+        @context.instance_exec(*args, &block)
+      end
+
+      def context_eval(&block)
+        @context.instance_eval(&block)
       end
     end
   end

data/lib/ddtrace/configuration/option_definition.rb

@@ -1,3 +1,5 @@
+require 'ddtrace/configuration/option'
+
 module Datadog
   module Configuration
     # Represents a definition for an integration configuration option
@@ -6,22 +8,120 @@ module Datadog
 
       attr_reader \
         :default,
+        :delegate_to,
         :depends_on,
         :lazy,
         :name,
+        :on_set,
+        :resetter,
         :setter
 
       def initialize(name, meta = {}, &block)
         @default = meta[:default]
+        @delegate_to = meta[:delegate_to]
         @depends_on = meta[:depends_on] || []
         @lazy = meta[:lazy] || false
         @name = name.to_sym
+        @on_set = meta[:on_set]
+        @resetter = meta[:resetter]
         @setter = meta[:setter] || block || IDENTITY
       end
 
       def default_value
         lazy ? @default.call : @default
       end
+
+      # Creates a new Option, bound to the context provided.
+      def build(context)
+        Option.new(self, context)
+      end
+
+      # Acts as DSL for building OptionDefinitions
+      class Builder
+        attr_reader \
+          :helpers
+
+        def initialize(name, options = {})
+          @default = nil
+          @delegate_to = nil
+          @depends_on = []
+          @helpers = {}
+          @lazy = false
+          @name = name.to_sym
+          @on_set = nil
+          @resetter = nil
+          @setter = OptionDefinition::IDENTITY
+
+          # If options were supplied, apply them.
+          apply_options!(options)
+
+          # Apply block if given.
+          yield(self) if block_given?
+        end
+
+        def depends_on(*values)
+          @depends_on = values.flatten
+        end
+
+        def default(value = nil, &block)
+          @default = block_given? ? block : value
+        end
+
+        def delegate_to(&block)
+          @delegate_to = block
+        end
+
+        def helper(name, *_args, &block)
+          @helpers[name] = block
+        end
+
+        # rubocop:disable Style/TrivialAccessors
+        # (Rubocop erroneously thinks #lazy == #lazy= )
+        def lazy(value = true)
+          @lazy = value
+        end
+
+        def on_set(&block)
+          @on_set = block
+        end
+
+        def resetter(&block)
+          @resetter = block
+        end
+
+        def setter(&block)
+          @setter = block
+        end
+
+        # For applying options for OptionDefinition
+        def apply_options!(options = {})
+          return if options.nil? || options.empty?
+
+          default(options[:default]) if options.key?(:default)
+          delegate_to(&options[:delegate_to]) if options.key?(:delegate_to)
+          depends_on(*options[:depends_on]) if options.key?(:depends_on)
+          lazy(options[:lazy]) if options.key?(:lazy)
+          on_set(&options[:on_set]) if options.key?(:on_set)
+          resetter(&options[:resetter]) if options.key?(:resetter)
+          setter(&options[:setter]) if options.key?(:setter)
+        end
+
+        def to_definition
+          OptionDefinition.new(@name, meta)
+        end
+
+        def meta
+          {
+            default: @default,
+            delegate_to: @delegate_to,
+            depends_on: @depends_on,
+            lazy: @lazy,
+            on_set: @on_set,
+            resetter: @resetter,
+            setter: @setter
+          }
+        end
+      end
     end
   end
 end

data/lib/ddtrace/configuration/options.rb

@@ -1,4 +1,3 @@
-require 'ddtrace/configuration/option'
 require 'ddtrace/configuration/option_set'
 require 'ddtrace/configuration/option_definition'
 require 'ddtrace/configuration/option_definition_set'
@@ -24,22 +23,33 @@ module Datadog
         protected
 
         def option(name, meta = {}, &block)
-          options[name] = OptionDefinition.new(name, meta, &block).tap do
-            define_option_accessors(name)
+          builder = OptionDefinition::Builder.new(name, meta, &block)
+          options[name] = builder.to_definition.tap do
+            # Resolve and define helper functions
+            helpers = default_helpers(name).merge(builder.helpers)
+            define_helpers(helpers)
           end
         end
 
         private
 
-        def define_option_accessors(name)
-          option_name = name
-
-          define_method(option_name) do
-            get_option(option_name)
-          end
+        def default_helpers(name)
+          option_name = name.to_sym
+
+          {
+            option_name.to_sym => proc do
+              get_option(option_name)
+            end,
+            "#{option_name}=".to_sym => proc do |value|
+              set_option(option_name, value)
+            end
+          }
+        end
 
-          define_method("#{option_name}=") do |value|
-            set_option(option_name, value)
+        def define_helpers(helpers)
+          helpers.each do |name, block|
+            next unless block.is_a?(Proc)
+            define_method(name, &block)
           end
         end
       end
@@ -60,7 +70,11 @@ module Datadog
           options[name].get
         end
 
-        def to_h
+        def option_defined?(name)
+          self.class.options.key?(name)
+        end
+
+        def options_hash
           options.each_with_object({}) do |(key, _), hash|
             hash[key] = get_option(key)
           end
@@ -75,13 +89,13 @@ module Datadog
         def add_option(name)
           assert_valid_option!(name)
           definition = self.class.options[name]
-          Option.new(definition, self).tap do |option|
+          definition.build(self).tap do |option|
             options[name] = option
           end
         end
 
         def assert_valid_option!(name)
-          unless self.class.options.key?(name)
+          unless option_defined?(name)
             raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
           end
         end