ls-trace 0.1.1

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,32 @@
+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
+
+        register_as :concurrent_ruby
+
+        def self.version
+          Gem.loaded_specs['concurrent-ruby'] && Gem.loaded_specs['concurrent-ruby'].version
+        end
+
+        def self.present?
+          super && defined?(::Concurrent::Future)
+        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,35 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # Patcher enables patching of 'Future' class.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:concurrent_ruby)
+        end
+
+        def patch
+          do_once(:concurrent_ruby) do
+            begin
+              require 'ddtrace/contrib/concurrent_ruby/future_patch'
+
+              patch_future
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Future integration: #{e}")
+            end
+          end
+        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,59 @@
+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
+
+        def configuration(key = :default)
+          configurations[resolve_configuration_key(key)]
+        end
+
+        def configurations
+          @configurations ||= Hash.new { default_configuration }.tap do |configs|
+            configs[:default] = default_configuration
+          end
+        end
+
+        def configure(key, options = {}, &block)
+          key = resolver.resolve(key || :default)
+
+          configurations[key].tap do |settings|
+            settings.configure(options, &block)
+            configurations[key] = settings
+          end
+        end
+
+        protected
+
+        attr_writer :resolver
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+
+        def resolve_configuration_key(key = :default)
+          key = :default if key.nil?
+          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,12 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a value to a configuration key
+      class Resolver
+        def resolve(name)
+          name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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 }
+        end
+
+        def configure(options = {})
+          self.class.options.dependency_order.each do |name|
+            self[name] = options.fetch(name, self[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
+      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,36 @@
+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
+
+        register_as :dalli, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['dalli'] && Gem.loaded_specs['dalli'].version
+        end
+
+        def self.present?
+          super && defined?(::Dalli)
+        end
+
+        def self.compatible?
+          super && version > Gem::Version.new('2.0.0')
+        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,73 @@
+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 patched?
+          done?(:dalli)
+        end
+
+        def patch
+          do_once(:dalli) do
+            begin
+              add_pin!
+              ::Dalli::Server.send(:include, Instrumentation)
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Dalli integration: #{e}")
+            end
+          end
+        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 tracer=(tracer)
+            Datadog.configuration[:dalli][:tracer] = tracer
+          end
+
+          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::Tracer.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'ddtrace/contrib/dalli/ext'
+
+module Datadog
+  module Contrib
+    module Dalli
+      # Quantize contains dalli-specic quantization tools.
+      module Quantize
+        module_function
+
+        def format_command(operation, args)
+          placeholder = "#{operation} BLOB (OMITTED)"
+          command = [operation, *args].join(' ').strip
+          command = Utils.utf8_encode(command, binary: true, placeholder: placeholder)
+          Utils.truncate(command, Ext::QUANTIZE_MAX_CMD_LENGTH)
+        rescue => e
+          Tracer.log.debug("Error sanitizing Dalli operation: #{e}")
+          placeholder
+        end
+      end
+    end
+  end
+end