ddtrace 0.20.0 → 0.21.0

data/lib/ddtrace/configuration/option_definition_set.rb

@@ -0,0 +1,18 @@
+require 'ddtrace/configuration/dependency_resolver'
+
+module Datadog
+  module Configuration
+    # Represents a set of configuration option definitions for an integration
+    class OptionDefinitionSet < Hash
+      def dependency_order
+        DependencyResolver.new(dependency_graph).call
+      end
+
+      def dependency_graph
+        each_with_object({}) do |(name, option), graph|
+          graph[name] = option.depends_on
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/option_set.rb

@@ -0,0 +1,6 @@
+module Datadog
+  module Configuration
+    class OptionSet < Hash
+    end
+  end
+end

data/lib/ddtrace/configuration/options.rb

@@ -0,0 +1,93 @@
+require 'ddtrace/configuration/option'
+require 'ddtrace/configuration/option_set'
+require 'ddtrace/configuration/option_definition'
+require 'ddtrace/configuration/option_definition_set'
+
+module Datadog
+  module Configuration
+    # Behavior for a configuration object that has options
+    module Options
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class behavior for a configuration object with options
+      module ClassMethods
+        def options
+          @options ||= begin
+            # Allows for class inheritance of option definitions
+            superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
+          end
+        end
+
+        protected
+
+        def option(name, meta = {}, &block)
+          options[name] = OptionDefinition.new(name, meta, &block).tap do
+            define_option_accessors(name)
+          end
+        end
+
+        private
+
+        def define_option_accessors(name)
+          option_name = name
+
+          define_method(option_name) do
+            get_option(option_name)
+          end
+
+          define_method("#{option_name}=") do |value|
+            set_option(option_name, value)
+          end
+        end
+      end
+
+      # Instance behavior for a configuration object with options
+      module InstanceMethods
+        def options
+          @options ||= OptionSet.new
+        end
+
+        def set_option(name, value)
+          add_option(name) unless options.key?(name)
+          options[name].set(value)
+        end
+
+        def get_option(name)
+          add_option(name) unless options.key?(name)
+          options[name].get
+        end
+
+        def to_h
+          options.each_with_object({}) do |(key, _), hash|
+            hash[key] = get_option(key)
+          end
+        end
+
+        def reset_options!
+          options.values.each(&:reset)
+        end
+
+        private
+
+        def add_option(name)
+          assert_valid_option!(name)
+          definition = self.class.options[name]
+          Option.new(definition, self).tap do |option|
+            options[name] = option
+          end
+        end
+
+        def assert_valid_option!(name)
+          unless self.class.options.key?(name)
+            raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
+          end
+        end
+      end
+
+      InvalidOptionError = Class.new(StandardError)
+    end
+  end
+end

data/lib/ddtrace/configuration/pin_setup.rb

@@ -1,5 +1,5 @@
 module Datadog
-  class Configuration
+  module Configuration
     # PinSetup translates a flat hash into a Pin configuration
     # This class should be removed if we ever remove/refactor the Pin class
     class PinSetup

data/lib/ddtrace/configuration/settings.rb

@@ -0,0 +1,47 @@
+require 'ddtrace/ext/analytics'
+require 'ddtrace/environment'
+require 'ddtrace/configuration/options'
+
+module Datadog
+  module Configuration
+    # Global configuration settings for the trace library.
+    class Settings
+      extend Datadog::Environment::Helpers
+      include Options
+
+      option  :analytics_enabled,
+              default: -> { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) },
+              lazy: true
+
+      option :tracer, default: Tracer.new
+
+      def initialize(options = {})
+        configure(options)
+      end
+
+      def configure(options = {})
+        self.class.options.dependency_order.each do |name|
+          next unless options.key?(name)
+          respond_to?("#{name}=") ? send("#{name}=", options[name]) : set_option(name, options[name])
+        end
+
+        yield(self) if block_given?
+      end
+
+      # Backwards compatibility for configuring tracer e.g. `c.tracer debug: true`
+      def tracer(options = nil)
+        tracer = options && options.key?(:instance) ? set_option(:tracer, options[:instance]) : get_option(:tracer)
+
+        tracer.tap do |t|
+          unless options.nil?
+            t.configure(options)
+            t.class.log = options[:log] if options[:log]
+            t.set_tags(options[:tags]) if options[:tags]
+            t.set_tags(env: options[:env]) if options[:env]
+            t.class.debug_logging = options.fetch(:debug, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_model_serializers/configuration/settings.rb

@@ -7,6 +7,14 @@ module Datadog
       module Configuration
         # Custom settings for the ActiveModelSerializers integration
         class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
           option :service_name, default: Ext::SERVICE_NAME
           option :tracer, default: Datadog.tracer do |value|
             (value || Datadog.tracer).tap do |v|

data/lib/ddtrace/contrib/active_model_serializers/event.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/ext/http'
+require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/active_support/notifications/event'
 require 'ddtrace/contrib/active_model_serializers/ext'
 
@@ -30,6 +31,11 @@ module Datadog
           def process(span, event, _id, payload)
             span.service = configuration[:service_name]
 
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
             # Set the resource name and serializer name
             res = resource(payload[:serializer])
             span.resource = res

data/lib/ddtrace/contrib/active_model_serializers/ext.rb

@@ -4,11 +4,11 @@ module Datadog
       # ActiveModelSerializers integration constants
       module Ext
         APP = 'active_model_serializers'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'active_model_serializers'.freeze
-
         SPAN_RENDER = 'active_model_serializers.render'.freeze
         SPAN_SERIALIZE = 'active_model_serializers.serialize'.freeze
-
         TAG_ADAPTER = 'active_model_serializers.adapter'.freeze
         TAG_SERIALIZER = 'active_model_serializers.serializer'.freeze
       end

data/lib/ddtrace/contrib/active_record/configuration/settings.rb

@@ -8,6 +8,14 @@ module Datadog
       module Configuration
         # Custom settings for the ActiveRecord integration
         class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
           option :orm_service_name
           option :service_name, depends_on: [:tracer] do |value|
             (value || Utils.adapter_name).tap do |service_name|

data/lib/ddtrace/contrib/active_record/events/instantiation.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/active_record/ext'
 require 'ddtrace/contrib/active_record/event'
 
@@ -38,6 +39,12 @@ module Datadog
 
             span.resource = payload.fetch(:class_name)
             span.span_type = Ext::SPAN_TYPE_INSTANTIATION
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
             span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
             span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
           rescue StandardError => e

data/lib/ddtrace/contrib/active_record/events/sql.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/active_record/ext'
 require 'ddtrace/contrib/active_record/event'
 
@@ -38,6 +39,11 @@ module Datadog
             span.resource = payload.fetch(:sql)
             span.span_type = Datadog::Ext::SQL::TYPE
 
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
             # Find out if the SQL query has been cached in this request. This meta is really
             # helpful to users because some spans may have 0ns of duration because the query
             # is simply cached from memory, so the notification is fired with start == finish.

data/lib/ddtrace/contrib/active_record/ext.rb

@@ -4,13 +4,12 @@ module Datadog
       # ActiveRecord integration constants
       module Ext
         APP = 'active_record'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTIVE_RECORD_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'active_record'.freeze
-
         SPAN_INSTANTIATION = 'active_record.instantiation'.freeze
         SPAN_SQL = 'active_record.sql'.freeze
-
         SPAN_TYPE_INSTANTIATION = 'custom'.freeze
-
         TAG_DB_CACHED = 'active_record.db.cached'.freeze
         TAG_DB_NAME = 'active_record.db.name'.freeze
         TAG_DB_VENDOR = 'active_record.db.vendor'.freeze

data/lib/ddtrace/contrib/analytics.rb

@@ -9,13 +9,12 @@ module Datadog
       # Checks whether analytics should be enabled.
       # `flag` is a truthy/falsey value that represents a setting on the integration.
       def enabled?(flag = nil)
-        # TODO: Check global flag here.
-        # (global_flag && flag != false) || flag == true
-        flag == true
+        (Datadog.configuration.analytics_enabled && flag != false) || flag == true
       end
 
       def set_sample_rate(span, sample_rate)
-        span.set_metric(Datadog::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate) unless sample_rate.nil?
+        return if span.nil? || sample_rate.nil?
+        span.set_metric(Datadog::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate)
       end
     end
   end

data/lib/ddtrace/contrib/aws/configuration/settings.rb

@@ -7,6 +7,14 @@ module Datadog
       module Configuration
         # Custom settings for the AWS integration
         class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
           option :service_name, default: Ext::SERVICE_NAME
         end
       end

data/lib/ddtrace/contrib/aws/ext.rb

@@ -4,17 +4,16 @@ module Datadog
       # AWS integration constants
       module Ext
         APP = 'aws'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_AWS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_AWS_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'aws'.freeze
-
         SPAN_COMMAND = 'aws.command'.freeze
-
         TAG_AGENT = 'aws.agent'.freeze
+        TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
+        TAG_HOST = 'host'.freeze
         TAG_OPERATION = 'aws.operation'.freeze
-        TAG_REGION = 'aws.region'.freeze
         TAG_PATH = 'path'.freeze
-        TAG_HOST = 'host'.freeze
-
-        TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
+        TAG_REGION = 'aws.region'.freeze
       end
     end
   end

data/lib/ddtrace/contrib/aws/instrumentation.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/aws/ext'
 
 module Datadog
@@ -27,6 +28,12 @@ module Datadog
           span.span_type = Datadog::Ext::AppTypes::WEB
           span.name = Ext::SPAN_COMMAND
           span.resource = context.safely(:resource)
+
+          # Set analytics sample rate
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+          end
+
           span.set_tag(Ext::TAG_AGENT, Ext::TAG_DEFAULT_AGENT)
           span.set_tag(Ext::TAG_OPERATION, context.safely(:operation))
           span.set_tag(Ext::TAG_REGION, context.safely(:region))

data/lib/ddtrace/contrib/configuration/settings.rb

@@ -1,11 +1,13 @@
-require 'ddtrace/contrib/configuration/options'
+require 'ddtrace/environment'
+require 'ddtrace/configuration/options'
 
 module Datadog
   module Contrib
     module Configuration
       # Common settings for all integrations
       class Settings
-        include Options
+        extend Datadog::Environment::Helpers
+        include Datadog::Configuration::Options
 
         option :service_name
         option :tracer, default: Datadog.tracer
@@ -31,18 +33,6 @@ module Datadog
         def []=(name, value)
           respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
         end
-
-        class << self
-          private
-
-          def env_to_bool(var, default = nil)
-            ENV.key?(var) ? ENV[var].to_s.downcase == 'true' : default
-          end
-
-          def env_to_float(var, default = nil)
-            ENV.key?(var) ? ENV[var].to_f : default
-          end
-        end
       end
     end
   end

data/lib/ddtrace/contrib/dalli/configuration/settings.rb

@@ -7,6 +7,14 @@ module Datadog
       module Configuration
         # Custom settings for the Dalli integration
         class Settings < Contrib::Configuration::Settings
+          option  :analytics_enabled,
+                  default: -> { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) },
+                  lazy: true
+
+          option  :analytics_sample_rate,
+                  default: -> { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) },
+                  lazy: true
+
           option :service_name, default: Ext::SERVICE_NAME
         end
       end

data/lib/ddtrace/contrib/dalli/ext.rb

@@ -4,9 +4,10 @@ module Datadog
       # Dalli integration constants
       module Ext
         APP = 'dalli'.freeze
-        SERVICE_NAME = 'memcached'.freeze
-
+        ENV_ANALYTICS_ENABLED = 'DD_DALLI_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_DALLI_ANALYTICS_SAMPLE_RATE'.freeze
         QUANTIZE_MAX_CMD_LENGTH = 100
+        SERVICE_NAME = 'memcached'.freeze
         SPAN_COMMAND = 'memcached.command'.freeze
         TAG_COMMAND = 'memcached.command'.freeze
       end

data/lib/ddtrace/contrib/dalli/instrumentation.rb

@@ -1,5 +1,6 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/dalli/quantize'
 
 module Datadog
@@ -35,6 +36,12 @@ module Datadog
               span.resource = op.to_s.upcase
               span.service = datadog_configuration[:service_name]
               span.span_type = Datadog::Ext::AppTypes::CACHE
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+              end
+
               span.set_tag(Datadog::Ext::NET::TARGET_HOST, hostname)
               span.set_tag(Datadog::Ext::NET::TARGET_PORT, port)
               cmd = Datadog::Contrib::Dalli::Quantize.format_command(op, args)