ddtrace 0.38.0

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

@@ -0,0 +1,11 @@
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # ConcurrentRuby integration constants
+      module Ext
+        APP = 'concurrent-ruby'.freeze
+        SERVICE_NAME = 'concurrent-ruby'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/future_patch.rb

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/concurrent_ruby/context_composite_executor_service'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+      module FuturePatch
+        def self.included(base)
+          base.class_eval do
+            alias_method :ns_initialize_without_datadog, :ns_initialize
+            remove_method(:ns_initialize)
+
+            def ns_initialize(value, opts)
+              ns_initialize_without_datadog(value, opts)
+
+              @executor = ContextCompositeExecutorService.new(@executor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/integration.rb

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/concurrent_ruby/patcher'
+require 'ddtrace/contrib/concurrent_ruby/configuration/settings'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # Describes the ConcurrentRuby integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('0.9')
+
+        register_as :concurrent_ruby
+
+        def self.version
+          Gem.loaded_specs['concurrent-ruby'] && Gem.loaded_specs['concurrent-ruby'].version
+        end
+
+        def self.loaded?
+          !defined?(::Concurrent::Future).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # Patcher enables patching of 'Future' class.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require 'ddtrace/contrib/concurrent_ruby/future_patch'
+          patch_future
+        end
+
+        # Propagate tracing context in Concurrent::Future
+        def patch_future
+          ::Concurrent::Future.send(:include, FuturePatch)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configurable.rb

@@ -0,0 +1,76 @@
+require 'ddtrace/contrib/configuration/resolver'
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    # Defines configurable behavior for integrations
+    module Configurable
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Configurable instance behavior for integrations
+      module InstanceMethods
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def reset_configuration!
+          @configurations = nil
+          @resolver = nil
+        end
+
+        # Get matching configuration for key.
+        # If no match, returns default configuration.
+        def configuration(key = :default)
+          configurations[configuration_key(key)]
+        end
+
+        # If the key has matching configuration explicitly defined for it,
+        # then return true. Otherwise return false.
+        def configuration_for?(key)
+          key = resolver.resolve(key) unless key == :default
+          configurations.key?(key)
+        end
+
+        def configurations
+          @configurations ||= {
+            default: default_configuration
+          }
+        end
+
+        # Create or update configuration with provided settings.
+        def configure(key, options = {}, &block)
+          key ||= :default
+
+          # Get or add the configuration
+          config = configuration_for?(key) ? configuration(key) : add_configuration(key)
+
+          # Apply the settings
+          config.configure(options, &block)
+          config
+        end
+
+        protected
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+
+        def add_configuration(key)
+          resolver.add(key)
+          config_key = resolver.resolve(key)
+          configurations[config_key] = default_configuration
+        end
+
+        def configuration_key(key)
+          return :default if key.nil? || key == :default
+
+          key = resolver.resolve(key)
+          key = :default unless configurations.key?(key)
+          key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a configuration key to a Datadog::Contrib::Configuration:Settings object
+      class Resolver
+        def resolve(key)
+          key
+        end
+
+        def add(key)
+          key
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/resolvers/pattern_resolver.rb

@@ -0,0 +1,39 @@
+require 'ddtrace/contrib/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a value to a configuration key
+      module Resolvers
+        # Matches strings against Regexps.
+        class PatternResolver < Datadog::Contrib::Configuration::Resolver
+          def resolve(name)
+            # Try to find a matching pattern
+            matching_pattern = patterns.find do |pattern|
+              # Rubocop incorrectly thinks assignment is done here...
+              # rubocop:disable Style/ConditionalAssignment
+              if pattern.is_a?(Proc)
+                pattern === name
+              else
+                pattern === name.to_s # Co-erce to string
+              end
+            end
+
+            # Return match or default
+            matching_pattern || :default
+          end
+
+          def add(pattern)
+            patterns << (pattern.is_a?(Regexp) || pattern.is_a?(Proc) ? pattern : pattern.to_s)
+          end
+
+          private
+
+          def patterns
+            @patterns ||= Set.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'ddtrace/configuration/base'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Common settings for all integrations
+      class Settings
+        include Datadog::Configuration::Base
+
+        option :analytics_enabled, default: false
+        option :analytics_sample_rate, default: 1.0
+        option :service_name
+        option :tracer do |o|
+          o.delegate_to { Datadog.tracer }
+          o.on_set do |_value|
+            log_deprecation_warning(:tracer)
+          end
+        end
+
+        def configure(options = {})
+          self.class.options.dependency_order.each do |name|
+            self[name] = options[name] if options.key?(name)
+          end
+
+          yield(self) if block_given?
+        end
+
+        def [](name)
+          respond_to?(name) ? send(name) : get_option(name)
+        end
+
+        def []=(name, value)
+          respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
+        end
+
+        DEPRECATION_WARNING = %(
+          Explicitly providing a tracer instance is DEPRECATED.
+          It's recommended to not provide an explicit tracer instance
+          and let Datadog::Contrib::Configuration::Settings resolve
+          the correct tracer internally.
+          ).freeze
+
+        include Datadog::Patcher # DEV includes #do_once here. We should move that logic to a generic component.
+
+        def log_deprecation_warning(method_name)
+          do_once(method_name) do
+            Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/dalli/ext'
+
+module Datadog
+  module Contrib
+    module Dalli
+      module Configuration
+        # Custom settings for the Dalli integration
+        class Settings < Contrib::Configuration::Settings
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module Dalli
+      # Dalli integration constants
+      module Ext
+        APP = 'dalli'.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
+        SPAN_TYPE_COMMAND = 'memcached'.freeze
+        TAG_COMMAND = 'memcached.command'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/dalli/ext'
+require 'ddtrace/contrib/dalli/quantize'
+
+module Datadog
+  module Contrib
+    module Dalli
+      # Instruments every interaction with the memcached server
+      module Instrumentation
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          def request(op, *args)
+            tracer.trace(Datadog::Contrib::Dalli::Ext::SPAN_COMMAND) do |span|
+              span.resource = op.to_s.upcase
+              span.service = datadog_configuration[:service_name]
+              span.span_type = Datadog::Contrib::Dalli::Ext::SPAN_TYPE_COMMAND
+
+              # 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)
+              span.set_tag(Datadog::Contrib::Dalli::Ext::TAG_COMMAND, cmd)
+
+              super
+            end
+          end
+
+          private
+
+          def tracer
+            datadog_configuration[:tracer]
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:dalli, "#{hostname}:#{port}"] || Datadog.configuration[:dalli]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/dalli/configuration/settings'
+require 'ddtrace/contrib/dalli/patcher'
+
+module Datadog
+  module Contrib
+    module Dalli
+      # Description of Dalli integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
+        register_as :dalli, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['dalli'] && Gem.loaded_specs['dalli'].version
+        end
+
+        def self.loaded?
+          !defined?(::Dalli).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/dalli/ext'
+require 'ddtrace/contrib/dalli/instrumentation'
+
+module Datadog
+  module Contrib
+    module Dalli
+      # Patcher enables patching of 'dalli' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          add_pin!
+          ::Dalli::Server.send(:include, Instrumentation)
+        end
+
+        # DEPRECATED: Only kept for users still using `Dalli.datadog_pin` to configure.
+        #             Replaced by configuration API, i.e. `c.use :dalli`.
+        def add_pin!
+          DeprecatedPin
+            .new(
+              get_option(:service_name),
+              app: Ext::APP,
+              app_type: Datadog::Ext::AppTypes::CACHE,
+              tracer: -> { get_option(:tracer) }
+            ).onto(::Dalli)
+        end
+
+        def get_option(option)
+          Datadog.configuration[:dalli].get_option(option)
+        end
+
+        # Implementation of deprecated Pin, which raises warnings when accessed.
+        # To be removed when support for Datadog::Pin with Dalli is removed.
+        class DeprecatedPin < Datadog::Pin
+          include Datadog::DeprecatedPin
+
+          DEPRECATION_WARNING = %(
+            Use of Datadog::Pin with Dalli is DEPRECATED.
+            Upgrade to the configuration API using the migration guide here:
+            https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
+
+          def service_name=(service_name)
+            Datadog.configuration[:dalli][:service_name] = service_name
+          end
+
+          def log_deprecation_warning(method_name)
+            do_once(method_name) do
+              Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
+            end
+          end
+        end
+      end
+    end
+  end
+end