ddtrace 0.53.0 → 0.54.1

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -0,0 +1,35 @@
+#include "extconf.h"
+
+// This file exports functions used to access private Ruby VM APIs and internals.
+// To do this, it imports a few VM internal (private) headers.
+//
+// **Important Note**: Our medium/long-term plan is to stop relying on all private Ruby headers, and instead request and
+// contribute upstream changes so that they become official public VM APIs.
+//
+// In the meanwhile, be very careful when changing things here :)
+
+#ifdef USE_MJIT_HEADER
+// Pick up internal structures from the private Ruby MJIT header file
+#include RUBY_MJIT_HEADER
+#else
+// On older Rubies, use a copy of the VM internal headers shipped in the debase-ruby_core_source gem
+#include <vm_core.h>
+#endif
+
+// MRI has a similar rb_thread_ptr() function which we can't call it directly
+// because Ruby does not expose the thread_data_type publicly.
+// Instead, we have our own version of that function, and we lazily initialize the thread_data_type pointer
+// from a known-correct object: the current thread.
+//
+// Note that beyond returning the rb_thread_struct*, rb_check_typeddata() raises an exception
+// if the argument passed in is not actually a `Thread` instance.
+static inline struct rb_thread_struct *thread_struct_from_object(VALUE thread) {
+  static const rb_data_type_t *thread_data_type = NULL;
+  if (thread_data_type == NULL) thread_data_type = RTYPEDDATA_TYPE(rb_thread_current());
+
+  return (struct rb_thread_struct *) rb_check_typeddata(thread, thread_data_type);
+}
+
+rb_nativethread_id_t pthread_id_for(VALUE thread) {
+  return thread_struct_from_object(thread)->thread_id;
+}

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -0,0 +1,3 @@
+#pragma once
+
+rb_nativethread_id_t pthread_id_for(VALUE thread);

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
-#include <stdio.h>
+
+#include "clock_id.h"
 
 static VALUE native_working_p(VALUE self);
 
@@ -10,8 +11,12 @@ void Init_ddtrace_profiling_native_extension(void) {
 
   rb_define_singleton_method(native_extension_module, "native_working?", native_working_p, 0);
   rb_funcall(native_extension_module, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("native_working?")));
+
+  rb_define_singleton_method(native_extension_module, "clock_id_for", clock_id_for, 1); // from clock_id.h
 }
 
 static VALUE native_working_p(VALUE self) {
+  self_test_clock_id();
+
   return Qtrue;
 }

data/lib/datadog/ci/contrib/cucumber/formatter.rb

@@ -39,6 +39,7 @@ module Datadog
                   service: configuration[:service_name]
                 },
                 framework: Ext::FRAMEWORK,
+                framework_version: Datadog::CI::Contrib::Cucumber::Integration.version.to_s,
                 test_name: event.test_case.name,
                 test_suite: event.test_case.location.file,
                 test_type: Ext::TEST_TYPE

data/lib/datadog/ci/contrib/rspec/example.rb

@@ -37,6 +37,7 @@ module Datadog
                     service: configuration[:service_name]
                   },
                   framework: Ext::FRAMEWORK,
+                  framework_version: Datadog::CI::Contrib::RSpec::Integration.version.to_s,
                   test_name: test_name,
                   test_suite: file_path,
                   test_type: Ext::TEST_TYPE

data/lib/datadog/ci/ext/environment.rb

@@ -40,22 +40,27 @@ module Datadog
         module_function
 
         def tags(env)
+          # Extract metadata from CI provider environment variables
           _, extractor = PROVIDERS.find { |provider_env_var, _| env.key?(provider_env_var) }
-          if extractor
-            tags = public_send(extractor, env)
-
-            tags[Datadog::Ext::Git::TAG_TAG] = normalize_ref(tags[Datadog::Ext::Git::TAG_TAG])
-            tags.delete(Datadog::Ext::Git::TAG_BRANCH) unless tags[Datadog::Ext::Git::TAG_TAG].nil?
-            tags[Datadog::Ext::Git::TAG_BRANCH] = normalize_ref(tags[Datadog::Ext::Git::TAG_BRANCH])
-            tags[Datadog::Ext::Git::TAG_REPOSITORY_URL] = filter_sensitive_info(tags[Datadog::Ext::Git::TAG_REPOSITORY_URL])
-
-            # Expand ~
-            workspace_path = tags[TAG_WORKSPACE_PATH]
-            if !workspace_path.nil? && (workspace_path == '~' || workspace_path.start_with?('~/'))
-              tags[TAG_WORKSPACE_PATH] = File.expand_path(workspace_path)
-            end
-          else
-            tags = {}
+          tags = extractor ? public_send(extractor, env).reject { |_, v| v.nil? || v.strip.empty? } : {}
+          tags.delete(Datadog::Ext::Git::TAG_BRANCH) unless tags[Datadog::Ext::Git::TAG_TAG].nil?
+
+          # If user defined metadata is defined, overwrite
+          tags.merge!(extract_user_defined_git(env))
+          if !tags[Datadog::Ext::Git::TAG_BRANCH].nil? && tags[Datadog::Ext::Git::TAG_BRANCH].include?('tags/')
+            tags[Datadog::Ext::Git::TAG_TAG] = tags[Datadog::Ext::Git::TAG_BRANCH]
+            tags.delete(Datadog::Ext::Git::TAG_BRANCH)
+          end
+
+          # Normalize Git references
+          tags[Datadog::Ext::Git::TAG_TAG] = normalize_ref(tags[Datadog::Ext::Git::TAG_TAG])
+          tags[Datadog::Ext::Git::TAG_BRANCH] = normalize_ref(tags[Datadog::Ext::Git::TAG_BRANCH])
+          tags[Datadog::Ext::Git::TAG_REPOSITORY_URL] = filter_sensitive_info(tags[Datadog::Ext::Git::TAG_REPOSITORY_URL])
+
+          # Expand ~
+          workspace_path = tags[TAG_WORKSPACE_PATH]
+          if !workspace_path.nil? && (workspace_path == '~' || workspace_path.start_with?('~/'))
+            tags[TAG_WORKSPACE_PATH] = File.expand_path(workspace_path)
           end
 
           # Fill out tags from local git as fallback
@@ -63,9 +68,6 @@ module Datadog
             tags[key] ||= value
           end
 
-          # If user defined metadata is defined, overwrite
-          tags.merge!(extract_user_defined_git(env))
-
           tags.reject { |_, v| v.nil? }
         end
 
@@ -211,16 +213,19 @@ module Datadog
           ref = env['GITHUB_REF'] if ref.nil? || ref.empty?
           branch, tag = branch_or_tag(ref)
 
+          pipeline_url = "#{env['GITHUB_SERVER_URL']}/#{env['GITHUB_REPOSITORY']}/actions/runs/#{env['GITHUB_RUN_ID']}"
+          pipeline_url = "#{pipeline_url}/attempts/#{env['GITHUB_RUN_ATTEMPT']}" if env['GITHUB_RUN_ATTEMPT']
+
           {
             Datadog::Ext::Git::TAG_BRANCH => branch,
             Datadog::Ext::Git::TAG_COMMIT_SHA => env['GITHUB_SHA'],
-            Datadog::Ext::Git::TAG_REPOSITORY_URL => "https://github.com/#{env['GITHUB_REPOSITORY']}.git",
+            Datadog::Ext::Git::TAG_REPOSITORY_URL => "#{env['GITHUB_SERVER_URL']}/#{env['GITHUB_REPOSITORY']}.git",
             Datadog::Ext::Git::TAG_TAG => tag,
-            TAG_JOB_URL => "https://github.com/#{env['GITHUB_REPOSITORY']}/commit/#{env['GITHUB_SHA']}/checks",
+            TAG_JOB_URL => "#{env['GITHUB_SERVER_URL']}/#{env['GITHUB_REPOSITORY']}/commit/#{env['GITHUB_SHA']}/checks",
             TAG_PIPELINE_ID => env['GITHUB_RUN_ID'],
             TAG_PIPELINE_NAME => env['GITHUB_WORKFLOW'],
             TAG_PIPELINE_NUMBER => env['GITHUB_RUN_NUMBER'],
-            TAG_PIPELINE_URL => "https://github.com/#{env['GITHUB_REPOSITORY']}/commit/#{env['GITHUB_SHA']}/checks",
+            TAG_PIPELINE_URL => pipeline_url,
             TAG_PROVIDER_NAME => 'github',
             TAG_WORKSPACE_PATH => env['GITHUB_WORKSPACE'],
             Datadog::Ext::Git::TAG_COMMIT_AUTHOR_NAME => env['BUILD_REQUESTEDFORID'],

data/lib/datadog/ci/ext/test.rb

@@ -8,6 +8,7 @@ module Datadog
 
         TAG_ARGUMENTS = 'test.arguments'.freeze
         TAG_FRAMEWORK = 'test.framework'.freeze
+        TAG_FRAMEWORK_VERSION = 'test.framework_version'.freeze
         TAG_NAME = 'test.name'.freeze
         TAG_SKIP_REASON = 'test.skip_reason'.freeze # DEV: Not populated yet
         TAG_STATUS = 'test.status'.freeze

data/lib/datadog/ci/test.rb

@@ -38,10 +38,14 @@ module Datadog
         span.context.origin = Ext::Test::CONTEXT_ORIGIN if span.context
         Datadog::Contrib::Analytics.set_measured(span)
         span.set_tag(Ext::Test::TAG_SPAN_KIND, Ext::AppTypes::TEST)
-        Ext::Environment.tags(ENV).each { |k, v| span.set_tag(k, v) }
+
+        # Set environment tags
+        @environment_tags ||= Ext::Environment.tags(ENV)
+        @environment_tags.each { |k, v| span.set_tag(k, v) }
 
         # Set contextual tags
         span.set_tag(Ext::Test::TAG_FRAMEWORK, tags[:framework]) if tags[:framework]
+        span.set_tag(Ext::Test::TAG_FRAMEWORK_VERSION, tags[:framework_version]) if tags[:framework_version]
         span.set_tag(Ext::Test::TAG_NAME, tags[:test_name]) if tags[:test_name]
         span.set_tag(Ext::Test::TAG_SUITE, tags[:test_suite]) if tags[:test_suite]
         span.set_tag(Ext::Test::TAG_TYPE, tags[:test_type]) if tags[:test_type]

data/lib/ddtrace/buffer.rb

@@ -14,7 +14,11 @@ module Datadog
     end
 
     # Add a new ``item`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random item is discarded.
+    # even if the buffer is full.
+    #
+    # When the buffer is full, we try to ensure that we are fairly sampling newly
+    # pushed traces by randomly inserting them into the buffer slots. This discards
+    # old traces randomly while trying to ensure that recent traces are still captured.
     def push(item)
       return if closed?
 
@@ -64,7 +68,7 @@ module Datadog
 
     protected
 
-    # Segment items into two distinct segments: underflow and overflow.
+    # Segment items into two segments: underflow and overflow.
     # Underflow are items that will fit into buffer.
     # Overflow are items that will exceed capacity, after underflow is added.
     # Returns each array, and nil if there is no underflow/overflow.
@@ -176,9 +180,6 @@ module Datadog
   # Buffer that stores objects, has a maximum size, and
   # can be safely used concurrently with CRuby.
   #
-  # Under extreme concurrency scenarios, this class can exceed
-  # its +max_size+ by up to 4%.
-  #
   # Because singular +Array+ operations are thread-safe in CRuby,
   # we can implement the trace buffer without an explicit lock,
   # while making the compromise of allowing the buffer to go
@@ -187,7 +188,6 @@ module Datadog
   # On the following scenario:
   # * 4.5 million spans/second.
   # * Pushed into a single CRubyTraceBuffer from 1000 threads.
-  # The buffer can exceed its maximum size by no more than 4%.
   #
   # This implementation allocates less memory and is faster
   # than {Datadog::ThreadSafeBuffer}.
@@ -195,19 +195,31 @@ module Datadog
   # @see spec/ddtrace/benchmark/buffer_benchmark_spec.rb Buffer benchmarks
   # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/c1114a0c6891d9634f019f1f9fe58dcae8658964/lib/concurrent-ruby/concurrent/array.rb#L23-L27
   class CRubyBuffer < Buffer
+    # A very large number to allow us to effectively
+    # drop all items when invoking `slice!(i, FIXNUM_MAX)`.
+    FIXNUM_MAX = (1 << 62) - 1
+
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
     # even if the buffer is full. In that case, a random trace is discarded.
     def replace!(item)
-      # we should replace a random trace with the new one
-      replace_index = rand(@items.size)
-      replaced_trace = @items.delete_at(replace_index)
-      @items << item
-
-      # We might have deleted an element right when the buffer
-      # was drained, thus +replaced_trace+ will be +nil+.
-      # In that case, nothing was replaced, and this method
-      # performed a simple insertion into the buffer.
-      replaced_trace
+      # Ensure buffer stays within +max_size+ items.
+      # This can happen when there's concurrent modification
+      # between a call the check in `full?` and the `add!` call in
+      # `full? ? replace!(item) : add!(item)`.
+      #
+      # We can still have `@items.size > @max_size` for a short period of
+      # time, but we will always try to correct it here.
+      #
+      # `slice!` is performed before `delete_at` & `<<` to avoid always
+      # removing the item that was just inserted.
+      #
+      # DEV: `slice!` with two integer arguments is ~10% faster than
+      # `slice!` with a {Range} argument.
+      @items.slice!(@max_size, FIXNUM_MAX)
+
+      # We should replace a random trace with the new one
+      replace_index = rand(@max_size)
+      @items[replace_index] = item
     end
   end
 

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -130,35 +130,46 @@ module Datadog
       def configured_port
         return @configured_port if defined?(@configured_port)
 
-        port_from_env = ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT]
         parsed_port_from_env =
-          if port_from_env
-            begin
-              Integer(port_from_env)
-            rescue ArgumentError
-              log_warning(
-                "Invalid value for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable " \
-                "('#{port_from_env}'). Ignoring this configuration."
-              )
-            end
-          end
+          try_parsing_as_integer(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
+            value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT],
+          )
+
+        parsed_settings_tracer_port =
+          try_parsing_as_integer(
+            friendly_name: '"c.tracer.port"',
+            value: settings.tracer.port,
+          )
 
         @configured_port = pick_from(
           DetectedConfiguration.new(
             friendly_name: '"c.tracer.port"',
-            value: settings.tracer.port
+            value: parsed_settings_tracer_port,
           ),
           DetectedConfiguration.new(
             friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
-            value: parsed_url && parsed_url.port
+            value: parsed_url && parsed_url.port,
           ),
           DetectedConfiguration.new(
             friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
-            value: parsed_port_from_env
+            value: parsed_port_from_env,
           )
         )
       end
 
+      def try_parsing_as_integer(value:, friendly_name:)
+        return unless value
+
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          log_warning("Invalid value for #{friendly_name} (#{value.inspect}). Ignoring this configuration.")
+
+          nil
+        end
+      end
+
       def ssl?
         !parsed_url.nil? && parsed_url.scheme == 'https'
       end
@@ -264,8 +275,8 @@ module Datadog
         log_warning(
           'Configuration mismatch: values differ between ' \
           "#{detected_configurations_in_priority_order
-            .map { |config| "#{config.friendly_name} ('#{config.value}')" }.join(' and ')}" \
-          ". Using '#{detected_configurations_in_priority_order.first.value}'."
+            .map { |config| "#{config.friendly_name} (#{config.value.inspect})" }.join(' and ')}" \
+          ". Using #{detected_configurations_in_priority_order.first.value.inspect}."
         )
       end
 

data/lib/ddtrace/context.rb

@@ -78,13 +78,21 @@ module Datadog
     # earlier while child spans still need to finish their traced execution.
     def current_span
       @mutex.synchronize do
-        return @current_span
+        @current_span
       end
     end
 
     def current_root_span
       @mutex.synchronize do
-        return @current_root_span
+        @current_root_span
+      end
+    end
+
+    # Same as calling #current_span and #current_root_span, but works atomically thus preventing races when we need to
+    # retrieve both
+    def current_span_and_root_span
+      @mutex.synchronize do
+        [@current_span, @current_root_span]
       end
     end
 

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -9,7 +9,7 @@ module Datadog
       # DelayedJob plugin that instruments invoke_job hook
       class Plugin < Delayed::Plugin
         def self.instrument_invoke(job, &block)
-          return block.call(job) unless tracer && tracer.enabled
+          return yield(job) unless tracer && tracer.enabled
 
           tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name(job),
                                       on_error: configuration[:error_handler]) do |span|
@@ -29,7 +29,7 @@ module Datadog
         end
 
         def self.instrument_enqueue(job, &block)
-          return block.call(job) unless tracer && tracer.enabled
+          return yield(job) unless tracer && tracer.enabled
 
           tracer.trace(Ext::SPAN_ENQUEUE, service: configuration[:client_service_name], resource: job_name(job)) do |span|
             set_sample_rate(span)

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

@@ -52,7 +52,7 @@ module Datadog
           module InstanceMethods
             def datadog_pin
               @datadog_pin ||= begin
-                service = Datadog.configuration[:mongo][:service_name]
+                service = Datadog.configuration[:mongo, seed][:service_name]
 
                 Datadog::Pin.new(
                   service,

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

@@ -1,5 +1,6 @@
 # typed: false
 require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/mongodb/configuration/settings'
 require 'ddtrace/contrib/mongodb/patcher'
 
@@ -33,6 +34,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

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

@@ -73,6 +73,13 @@ module Datadog
             end
           end
 
+          option :job_service do |o|
+            o.on_set do |value|
+              # Update ActiveJob service name too
+              Datadog.configuration[:active_job][:service_name] = value
+            end
+          end
+
           option :middleware, default: true
           option :middleware_names, default: false
           option :template_base_path do |o|

data/lib/ddtrace/contrib/rails/framework.rb

@@ -22,7 +22,7 @@ module Datadog
       # Rails framework code, used to essentially:
       # - handle configuration entries which are specific to Datadog tracing
       # - instrument parts of the framework when needed
-      module Framework
+      module Framework # rubocop:disable Metrics/ModuleLength
         # After the Rails application finishes initializing, we configure the Rails
         # integration and all its sub-components with the application information
         # available.
@@ -65,6 +65,7 @@ module Datadog
             config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
             config[:controller_service] ||= config[:service_name]
             config[:cache_service] ||= "#{config[:service_name]}-cache"
+            config[:job_service] ||= "#{config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}"
           end
         end
 
@@ -132,7 +133,7 @@ module Datadog
 
           datadog_config.use(
             :active_job,
-            service_name: "#{rails_config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}",
+            service_name: rails_config[:job_service],
             log_injection: rails_config[:log_injection]
           )
         end

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

@@ -0,0 +1,90 @@
+# typed: false
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/redis/ext'
+require 'ddtrace/contrib/redis/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Instrumentation for Redis
+      module Instrumentation
+        def self.included(base)
+          base.prepend(InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          def call(*args, &block)
+            pin = Datadog::Pin.get_from(self)
+            return super unless pin && pin.tracer
+
+            response = nil
+            pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              span.service = pin.service
+              span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+              span.resource = get_command(args)
+              Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+              response = super
+            end
+
+            response
+          end
+
+          def call_pipeline(*args, &block)
+            pin = Datadog::Pin.get_from(self)
+            return super unless pin && pin.tracer
+
+            response = nil
+            pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              span.service = pin.service
+              span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+              commands = get_pipeline_commands(args)
+              span.resource = commands.join("\n")
+              span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+              Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+              response = super
+            end
+
+            response
+          end
+
+          def datadog_pin
+            @datadog_pin ||= begin
+              pin = Datadog::Pin.new(
+                datadog_configuration[:service_name],
+                app: Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: -> { datadog_configuration[:tracer] }
+              )
+              pin.onto(self)
+            end
+          end
+
+          private
+
+          def get_command(args)
+            if datadog_configuration[:command_args]
+              Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+            else
+              Datadog::Contrib::Redis::Quantize.get_verb(*args)
+            end
+          end
+
+          def get_pipeline_commands(args)
+            if datadog_configuration[:command_args]
+              args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+            else
+              args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
+            end
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:redis, options]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,92 +23,10 @@ module Datadog
           require 'ddtrace/ext/app_types'
           require 'ddtrace/contrib/redis/tags'
           require 'ddtrace/contrib/redis/quantize'
+          require 'ddtrace/contrib/redis/instrumentation'
 
-          patch_redis_client
+          ::Redis::Client.include(Instrumentation)
         end
-
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/BlockLength
-        # rubocop:disable Metrics/AbcSize
-        def patch_redis_client
-          ::Redis::Client.class_eval do
-            alias_method :call_without_datadog, :call
-            remove_method :call
-            def call(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                span.resource = get_command(args)
-                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-
-                response = call_without_datadog(*args, &block)
-              end
-
-              response
-            end
-
-            alias_method :call_pipeline_without_datadog, :call_pipeline
-            remove_method :call_pipeline
-            def call_pipeline(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                commands = get_pipeline_commands(args)
-                span.resource = commands.join("\n")
-                span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-
-                response = call_pipeline_without_datadog(*args, &block)
-              end
-
-              response
-            end
-
-            def datadog_pin
-              @datadog_pin ||= begin
-                pin = Datadog::Pin.new(
-                  datadog_configuration[:service_name],
-                  app: Ext::APP,
-                  app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: -> { datadog_configuration[:tracer] }
-                )
-                pin.onto(self)
-              end
-            end
-
-            private
-
-            def get_command(args)
-              if datadog_configuration[:command_args]
-                Datadog::Contrib::Redis::Quantize.format_command_args(*args)
-              else
-                Datadog::Contrib::Redis::Quantize.get_verb(*args)
-              end
-            end
-
-            def get_pipeline_commands(args)
-              if datadog_configuration[:command_args]
-                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
-              else
-                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
-              end
-            end
-
-            def datadog_configuration
-              Datadog.configuration[:redis, options]
-            end
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/BlockLength
       end
     end
   end

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

@@ -11,8 +11,6 @@ module Datadog
         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('3.0')
 
         register_as :resque, auto_patch: true
 
@@ -25,9 +23,7 @@ module Datadog
         end
 
         def self.compatible?
-          super \
-            && version >= MINIMUM_VERSION \
-            && version < MAXIMUM_VERSION
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration