datadog 2.0.0.beta1

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Tags handles generic common tags assignment.
+        module Tags
+          class << self
+            def set_common_tags(client, span, raw_command)
+              if datadog_configuration[:peer_service]
+                span.set_tag(
+                  Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                  datadog_configuration[:peer_service]
+                )
+              end
+
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, client.host)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+              span.set_tag Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM
+
+              span.set_tag Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, client.host
+              span.set_tag Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, client.port
+
+              span.set_tag Ext::TAG_DATABASE_INDEX, client.db.to_s
+              span.set_tag Ext::TAG_DB, client.db
+              span.set_tag Ext::TAG_RAW_COMMAND, raw_command
+
+              Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.tracing[: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
+end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'quantize'
+require_relative 'tags'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Instrumentation for Redis 5+
+        module TraceMiddleware
+          # Instruments {RedisClient::ConnectionMixin#call}.
+          def call(command, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call(redis_config, command, config[:service_name], config[:command_args]) { super }
+          end
+
+          # Instruments {RedisClient::ConnectionMixin#call_pipelined}.
+          def call_pipelined(commands, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call_pipelined(redis_config, commands, config[:service_name], config[:command_args]) { super }
+          end
+
+          class << self
+            def call(client, command, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_command(command, true)
+                span.resource = command_args ? raw_command : get_command(command, false)
+
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
+
+                yield
+              end
+            end
+
+            def call_pipelined(client, commands, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_pipeline_commands(commands, true)
+                span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
+
+                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
+
+                yield
+              end
+            end
+
+            private
+
+            # Quantizes a single Redis command
+            def get_command(command, command_args)
+              if command_args
+                Contrib::Redis::Quantize.format_command_args(command)
+              else
+                Contrib::Redis::Quantize.get_verb(command)
+              end
+            end
+
+            # Quantizes a multi-command Redis pipeline execution
+            def get_pipeline_commands(commands, command_args)
+              list = if command_args
+                       commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+                     else
+                       commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+                     end
+
+              list.empty? ? '(none)' : list.join("\n")
+            end
+          end
+
+          private
+
+          def resolve(redis_config)
+            custom = redis_config.custom[:datadog] || {}
+
+            Datadog.configuration.tracing[:redis, redis_config.server_url].to_h.merge(custom)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/redis/vendor/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ezra Zygmuntowicz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/datadog/tracing/contrib/redis/vendor/resolver.rb

@@ -0,0 +1,160 @@
+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 Tracing
+    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.each_key do |key|
+                # Fill in defaults if needed
+                defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
+
+                # 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)
+
+                case uri.scheme
+                when 'unix'
+                  defaults[:path] = uri.path
+                when 'redis', '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.each_key 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
+end

data/lib/datadog/tracing/contrib/registerable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Defines registerable behavior for integrations
+      module Registerable
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        # Class methods for registerable behavior
+        # @public_api
+        module ClassMethods
+          # Registers this integration in the global tracer registry.
+          # Once registered, this integration can be activated with:
+          #
+          # ```
+          # Datadog.configure do |c|
+          #   c.tracing.instrument :name
+          # end
+          # ```
+          #
+          # @param [Symbol] name integration name. Used during activation.
+          # @param [Datadog::Tracing::Contrib::Registry] registry a custom registry.
+          #        Defaults to the global tracing registry.
+          # @param [Boolean] auto_patch will this integration be activated during
+          #   {file:docs/AutoInstrumentation.md Auto Instrumentation}?
+          # @param [Hash] options additional keyword options passed to the initializer of
+          #   a custom {Registerable} instrumentation
+          # @see Datadog::Tracing::Contrib::Integration
+          def register_as(name, registry: Contrib::REGISTRY, auto_patch: false, **options)
+            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
+end

data/lib/datadog/tracing/contrib/registry.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Registry is a collection of tracing integrations.
+      # @public_api
+      class Registry
+        include Enumerable
+
+        Entry = Struct.new(:name, :klass, :auto_patch)
+
+        # @!visibility private
+        def initialize
+          @data = {}
+          @mutex = Mutex.new
+        end
+
+        # @param name [Symbol] instrumentation name, to be used when activating this integration
+        # @param klass [Object] instrumentation implementation
+        # @param auto_patch [Boolean] is the tracer allowed to automatically patch
+        #   the host application with this instrumentation?
+        def add(name, klass, auto_patch = false)
+          @mutex.synchronize do
+            @data[name] = Entry.new(name, klass, auto_patch).freeze
+          end
+        end
+
+        def each(&block)
+          @mutex.synchronize do
+            @data.each_value(&block)
+          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
+end

data/lib/datadog/tracing/contrib/resque/configuration/settings.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        module Configuration
+          # Custom settings for the Resque integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/ext.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Resque integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'resque'
+          SPAN_JOB = 'resque.job'
+          TAG_COMPONENT = 'resque'
+          TAG_OPERATION_JOB = 'job'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/integration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Description of Resque integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 >= MINIMUM_VERSION
+          end
+
+          def new_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
+end

data/lib/datadog/tracing/contrib/resque/patcher.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative '../sidekiq/ext'
+
+module Datadog
+  module Tracing
+    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'
+
+            ::Resque::Job.prepend(Resque::Job)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/resque_job.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'resque'
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../sidekiq/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Automatically configures jobs with {ResqueJob} plugin.
+        module Job
+          def perform
+            job = payload_class
+            job.extend(Contrib::Resque::ResqueJob) unless job.is_a?(Contrib::Resque::ResqueJob)
+          ensure
+            super
+          end
+        end
+
+        # Uses Resque job hooks to create traces
+        module ResqueJob
+          # `around_perform` hooks are executed in alphabetical order.
+          # we use the lowest printable character that allows for an inline
+          # method definition ('0'), alongside our naming prefix for identification.
+          #
+          # We could, in theory, use any character (e.g "\x00"), but this will lead
+          # to unreadable stack traces that contain this method call.
+          #
+          # We could also just use `around_perform` but this might override the user's
+          # own method.
+          def around_perform0_datadog(*args)
+            return yield unless datadog_configuration && Tracing.enabled?
+
+            Tracing.trace(Ext::SPAN_JOB, **span_options) do |span|
+              span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
+              span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
+              # 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!
+            Tracing.shutdown! if forked?
+          end
+
+          private
+
+          def forked?
+            Datadog.configuration_for(::Resque, :forked) == true
+          end
+
+          def span_options
+            { service: datadog_configuration[:service_name], on_error: datadog_configuration[:on_error] }
+          end
+
+          def datadog_configuration
+            Datadog.configuration.tracing[:resque]
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque.after_fork do
+  configuration = Datadog.configuration.tracing[:resque]
+  next if configuration.nil?
+
+  # Add a pin, marking the job as forked.
+  # Used to trigger shutdown in forks for performance reasons.
+  Datadog.configure_onto(::Resque, forked: true)
+
+  # Clean the state so no CoW happens
+  # TODO: Remove this. Should be obsolete with new context management.
+  #       But leave this in the interim... should be safe.
+  tracer = Datadog::Tracing.send(:tracer)
+  next if tracer.nil?
+
+  tracer.provider.context = nil
+end