ddtrace 0.38.0

data/lib/ddtrace/contrib/redis/tags.rb

@@ -0,0 +1,38 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/redis/ext'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Tags handles generic common tags assignment.
+      module Tags
+        class << self
+          def set_common_tags(client, span)
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
+            span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
+            span.set_tag Ext::TAG_DB, client.db
+            span.set_tag Ext::TAG_RAW_COMMAND, span.resource
+          end
+
+          private
+
+          def datadog_configuration
+            Datadog.configuration[:redis]
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/redis/vendor/resolver.rb

@@ -0,0 +1,159 @@
+require 'uri'
+
+# NOTE: This code is copied directly from Redis.
+#       Its purpose is to resolve connection information.
+#       It exists here only because it doesn't exist in the redis
+#       library as a separated module and it allows to avoid
+#       instantiating a new Redis::Client for resolving the connection
+module Datadog
+  module Contrib
+    module Redis
+      module Vendor
+        class Resolver # :nodoc:
+          # Connection DEFAULTS for a Redis::Client are unchanged for
+          # the integration supported options.
+          # https://github.com/redis/redis-rb/blob/v3.0.0/lib/redis/client.rb#L6-L14
+          # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb#L10-L26
+          # Since the integration takes in consideration only few attributes, all
+          # versions are compatible for :url, :scheme, :host, :port, :db
+          DEFAULTS = {
+            url: -> { ENV['REDIS_URL'] },
+            scheme: 'redis',
+            host: '127.0.0.1',
+            port: 6379,
+            path: nil,
+            # :timeout => 5.0,
+            password: nil,
+            db: 0 # ,
+            # :driver => nil,
+            # :id => nil,
+            # :tcp_keepalive => 0,
+            # :reconnect_attempts => 1,
+            # :reconnect_delay => 0,
+            # :reconnect_delay_max => 0.5,
+            # :inherit_socket => false
+          }.freeze
+
+          def resolve(options)
+            _parse_options(options)
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/PerceivedComplexity
+          #
+          # This method is a subset of the implementation provided in v3.0.0
+          # https://github.com/redis/redis-rb/blob/v3.0.0/lib/redis/client.rb
+          # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb
+          #
+          # Since it has been backported from the original gem, some linting
+          # cops have been disabled
+          def _parse_options(options)
+            # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb#L404
+            # Early return for modern client options
+            return options if options[:_parsed]
+
+            defaults = DEFAULTS.dup
+            options = options.dup
+
+            defaults.keys.each do |key|
+              # Fill in defaults if needed
+              if defaults[key].respond_to?(:call)
+                defaults[key] = defaults[key].call
+              end
+
+              # Symbolize only keys that are needed
+              options[key] = options[key.to_s] if options.key?(key.to_s)
+            end
+
+            url = options[:url]
+            url = defaults[:url] if url.nil?
+
+            # Override defaults from URL if given
+            if url
+              uri = URI(url)
+
+              if uri.scheme == 'unix'
+                defaults[:path] = uri.path
+              elsif uri.scheme == 'redis' || uri.scheme == 'rediss'
+                defaults[:scheme]   = uri.scheme
+                defaults[:host]     = uri.host if uri.host
+                defaults[:port]     = uri.port if uri.port
+                defaults[:password] = CGI.unescape(uri.password) if uri.password
+                defaults[:db]       = uri.path[1..-1].to_i if uri.path
+                defaults[:role] = :master
+              else
+                raise ArgumentError, "invalid uri scheme '#{uri.scheme}'"
+              end
+
+              # defaults[:ssl] = true if uri.scheme == "rediss"
+            end
+
+            # Use default when option is not specified or nil
+            defaults.keys.each do |key|
+              options[key] = defaults[key] if options[key].nil?
+            end
+
+            if options[:path]
+              # Unix socket
+              options[:scheme] = 'unix'
+              options.delete(:host)
+              options.delete(:port)
+            else
+              # TCP socket
+              options[:host] = options[:host].to_s
+              options[:port] = options[:port].to_i
+            end
+
+            # Options ignored by the integration
+            #
+            # if options.has_key?(:timeout)
+            #   options[:connect_timeout] ||= options[:timeout]
+            #   options[:read_timeout]    ||= options[:timeout]
+            #   options[:write_timeout]   ||= options[:timeout]
+            # end
+
+            # options[:connect_timeout] = Float(options[:connect_timeout])
+            # options[:read_timeout]    = Float(options[:read_timeout])
+            # options[:write_timeout]   = Float(options[:write_timeout])
+
+            # options[:reconnect_attempts] = options[:reconnect_attempts].to_i
+            # options[:reconnect_delay] = options[:reconnect_delay].to_f
+            # options[:reconnect_delay_max] = options[:reconnect_delay_max].to_f
+
+            options[:db] = options[:db].to_i
+            # options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
+
+            # case options[:tcp_keepalive]
+            # when Hash
+            #   [:time, :intvl, :probes].each do |key|
+            #     unless options[:tcp_keepalive][key].is_a?(Integer)
+            #       raise "Expected the #{key.inspect} key in :tcp_keepalive to be an Integer"
+            #     end
+            #   end
+
+            # when Integer
+            #   if options[:tcp_keepalive] >= 60
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
+
+            #   elsif options[:tcp_keepalive] >= 30
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2}
+
+            #   elsif options[:tcp_keepalive] >= 5
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1}
+            #   end
+            # end
+
+            options[:_parsed] = true
+
+            options
+          end
+
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/PerceivedComplexity
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/registerable.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/contrib/registry'
+
+module Datadog
+  module Contrib
+    # Defines registerable behavior for integrations
+    module Registerable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for registerable behavior
+      module ClassMethods
+        def register_as(name, options = {})
+          registry = options.fetch(:registry, Datadog.registry)
+          auto_patch = options.fetch(:auto_patch, false)
+
+          registry.add(name, new(name, options), auto_patch)
+        end
+      end
+
+      # Instance methods for registerable behavior
+      module InstanceMethods
+        attr_reader \
+          :name
+
+        def initialize(name, options = {})
+          @name = name
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/registry.rb

@@ -0,0 +1,42 @@
+module Datadog
+  module Contrib
+    # Registry is a collection of integrations.
+    class Registry
+      include Enumerable
+
+      Entry = Struct.new(:name, :klass, :auto_patch)
+
+      def initialize
+        @data = {}
+        @mutex = Mutex.new
+      end
+
+      def add(name, klass, auto_patch = false)
+        @mutex.synchronize do
+          @data[name] = Entry.new(name, klass, auto_patch).freeze
+        end
+      end
+
+      def each
+        @mutex.synchronize do
+          @data.each { |_, entry| yield(entry) }
+        end
+      end
+
+      def [](name)
+        @mutex.synchronize do
+          entry = @data[name]
+          entry.klass if entry
+        end
+      end
+
+      def to_h
+        @mutex.synchronize do
+          @data.each_with_object({}) do |(_, entry), hash|
+            hash[entry.name] = entry.auto_patch
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/resque/ext'
+
+module Datadog
+  module Contrib
+    module Resque
+      module Configuration
+        # Custom settings for the Resque 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
+          option :workers, default: []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Datadog
+  module Contrib
+    module Resque
+      # Resque integration constants
+      module Ext
+        APP = 'resque'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_RESQUE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'resque'.freeze
+        SPAN_JOB = 'resque.job'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/resque/configuration/settings'
+require 'ddtrace/contrib/resque/patcher'
+
+module Datadog
+  module Contrib
+    module Resque
+      # Description of Resque integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('1.0')
+        # Maximum is first version it's NOT compatible with (not inclusive)
+        MAXIMUM_VERSION = Gem::Version.new('2.0')
+
+        register_as :resque, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['resque'] && Gem.loaded_specs['resque'].version
+        end
+
+        def self.loaded?
+          !defined?(::Resque).nil?
+        end
+
+        def self.compatible?
+          super \
+            && version >= Gem::Version.new('1.0') \
+            && version < MAXIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+
+        class << self
+          # Globally-acccesible reference for pre-forking optimization
+          attr_accessor :sync_writer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sidekiq/ext'
+
+module Datadog
+  module Contrib
+    module Resque
+      # Patcher enables patching of 'resque' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require_relative 'resque_job'
+          get_option(:workers).each { |worker| worker.extend(ResqueJob) }
+        end
+
+        def get_option(option)
+          Datadog.configuration[:resque].get_option(option)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -0,0 +1,80 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/sync_writer'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/sidekiq/ext'
+require 'resque'
+
+module Datadog
+  module Contrib
+    module Resque
+      # Uses Resque job hooks to create traces
+      module ResqueJob
+        def around_perform(*args)
+          return yield unless datadog_configuration && tracer
+
+          tracer.trace(Ext::SPAN_JOB, span_options) do |span|
+            span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            yield
+          end
+        end
+
+        def after_perform_shutdown_tracer(*_)
+          shutdown_tracer_when_forked!
+        end
+
+        def on_failure_shutdown_tracer(*_)
+          shutdown_tracer_when_forked!
+        end
+
+        def shutdown_tracer_when_forked!
+          tracer.shutdown! if forked?
+        end
+
+        private
+
+        def forked?
+          pin = Datadog::Pin.get_from(::Resque)
+          return false unless pin
+          pin.config[:forked] == true
+        end
+
+        def span_options
+          { service: datadog_configuration[:service_name] }
+        end
+
+        def tracer
+          datadog_configuration.tracer
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:resque]
+        end
+      end
+    end
+  end
+end
+
+Resque.after_fork do
+  configuration = Datadog.configuration[:resque]
+  next if configuration.nil?
+
+  # Add a pin, marking the job as forked.
+  # Used to trigger shutdown in forks for performance reasons.
+  Datadog::Pin.new(
+    configuration[:service_name],
+    config: { forked: true }
+  ).onto(::Resque)
+
+  # Clean the state so no CoW happens
+  next if configuration[:tracer].nil?
+  configuration[:tracer].provider.context = nil
+end