ddtrace 1.21.1 → 1.22.0

data/lib/datadog/core/telemetry/http/transport.rb

@@ -39,10 +39,15 @@ module Datadog
 
           def headers(request_type:, api_version: Http::Ext::API_VERSION)
             {
-              Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
-              Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
-              Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
-              Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,
+              Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
+              Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
+              Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
+              Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,
+              Ext::HEADER_CLIENT_LIBRARY_LANGUAGE => Core::Environment::Ext::LANG,
+              Ext::HEADER_CLIENT_LIBRARY_VERSION => DDTrace::VERSION::STRING,
+
+              # Enable debug mode for telemetry
+              # HEADER_TELEMETRY_DEBUG_ENABLED => 'true',
             }
           end
 

data/lib/datadog/core/telemetry/request.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../environment/platform'
+require_relative '../utils/hash'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Module defining methods for collecting metadata for telemetry
+      module Request
+        class << self
+          using Core::Utils::Hash::Refinement
+
+          def build_payload(event, seq_id)
+            hash = {
+              api_version: Http::Ext::API_VERSION,
+              application: application,
+              debug: false,
+              host: host,
+              payload: event.payload(seq_id),
+              request_type: event.type,
+              runtime_id: Core::Environment::Identity.id,
+              seq_id: seq_id,
+              tracer_time: Time.now.to_i,
+            }
+            hash.compact!
+            hash
+          end
+
+          private
+
+          def application
+            config = Datadog.configuration
+            {
+              env: config.env,
+              language_name: Core::Environment::Ext::LANG,
+              language_version: Core::Environment::Ext::LANG_VERSION,
+              runtime_name: Core::Environment::Ext::RUBY_ENGINE,
+              runtime_version: Core::Environment::Ext::ENGINE_VERSION,
+              service_name: config.service,
+              service_version: config.version,
+              tracer_version: Core::Environment::Identity.tracer_version
+            }
+          end
+
+          def host
+            {
+              architecture: Core::Environment::Platform.architecture,
+              hostname: Core::Environment::Platform.hostname,
+              kernel_name: Core::Environment::Platform.kernel_name,
+              kernel_release: Core::Environment::Platform.kernel_release,
+              kernel_version: Core::Environment::Platform.kernel_version
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -97,14 +97,20 @@ module Datadog
           end
         end
 
-        Library = Struct.new(:kind, :name, :version, :path) do
+        # Represents metadata we have for a ruby gem
+        class Library
+          attr_reader :kind, :name, :version, :path
+
           def initialize(kind:, name:, version:, path:)
-            super(kind.freeze, name.dup.freeze, version.to_s.dup.freeze, path.dup.freeze)
+            @kind = kind.freeze
+            @name = name.dup.freeze
+            @version = version.to_s.dup.freeze
+            @path = path.dup.freeze
             freeze
           end
 
-          def to_json(*args)
-            { kind: kind, name: name, version: version, paths: [path] }.to_json(*args)
+          def to_json(arg = nil)
+            { kind: @kind, name: @name, version: @version, paths: [@path] }.to_json(arg)
           end
         end
       end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -22,6 +22,7 @@ module Datadog
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
+          skip_idle_samples_for_testing: false,
           idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
@@ -39,11 +40,14 @@ module Datadog
             dynamic_sampling_rate_enabled,
             dynamic_sampling_rate_overhead_target_percentage,
             allocation_profiling_enabled,
+            skip_idle_samples_for_testing,
           )
           @worker_thread = nil
           @failure_exception = nil
           @start_stop_mutex = Mutex.new
           @idle_sampling_helper = idle_sampling_helper
+          @wait_until_running_mutex = Mutex.new
+          @wait_until_running_condition = ConditionVariable.new
         end
 
         def start(on_failure_proc: nil)
@@ -106,6 +110,27 @@ module Datadog
           self.class._native_stats_reset_not_thread_safe(self)
           stats
         end
+
+        # Useful for testing, to e.g. make sure the profiler is running before we start running some code we want to observe
+        def wait_until_running(timeout_seconds: 5)
+          @wait_until_running_mutex.synchronize do
+            return true if self.class._native_is_running?(self)
+
+            @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
+
+            if self.class._native_is_running?(self)
+              true
+            else
+              raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
+            end
+          end
+        end
+
+        private
+
+        def signal_running
+          @wait_until_running_mutex.synchronize { @wait_until_running_condition.broadcast }
+        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -111,19 +111,30 @@ module Datadog
       end
 
       private_class_method def self.enable_gc_profiling?(settings)
-        # See comments on the setting definition for more context on why it exists.
-        if settings.profiling.advanced.force_enable_gc_profiling
-          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3')
-            Datadog.logger.debug(
-              'Profiling time/resources spent in Garbage Collection force enabled. Do not use Ractors in combination ' \
-              'with this option as profiles will be incomplete.'
-            )
-          end
+        return false unless settings.profiling.advanced.gc_enabled
 
-          true
-        else
-          false
+        # SEVERE - Only with Ractors
+        # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 gc profiling can trigger a VM bug
+        # that causes a segmentation fault during garbage collection of Ractors
+        # (https://bugs.ruby-lang.org/issues/18464). We don't allow enabling gc profiling on such Rubies.
+        # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
+        if RUBY_VERSION.start_with?('3.0.') ||
+            (RUBY_VERSION.start_with?('3.1.') && RUBY_VERSION < '3.1.4') ||
+            (RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION < '3.2.3')
+          Datadog.logger.warn(
+            "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling GC profiling would cause "\
+            'crashes (https://bugs.ruby-lang.org/issues/18464). GC profiling has been disabled.'
+          )
+          return false
+        elsif RUBY_VERSION.start_with?('3.')
+          Datadog.logger.debug(
+            'In all known versions of Ruby 3.x, using Ractors may result in GC profiling unexpectedly ' \
+            'stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your ' \
+            'application stability or performance. This does not happen if Ractors are not used.'
+          )
         end
+
+        true
       end
 
       private_class_method def self.get_heap_sample_every(settings)
@@ -135,10 +146,7 @@ module Datadog
       end
 
       private_class_method def self.enable_allocation_profiling?(settings)
-        unless settings.profiling.allocation_enabled
-          # Allocation profiling disabled, short-circuit out
-          return false
-        end
+        return false unless settings.profiling.allocation_enabled
 
         # Allocation sampling is safe and supported on Ruby 2.x, but has a few caveats on Ruby 3.x.
 

data/lib/datadog/profiling/load_native_extension.rb

@@ -18,7 +18,20 @@ rescue LoadError => e
 end
 
 extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-full_file_path = "#{__dir__}/../../#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+file_name = "#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+full_file_path = "#{__dir__}/../../#{file_name}"
+
+unless File.exist?(full_file_path)
+  extension_dir = Gem.loaded_specs['ddtrace'].extension_dir
+  candidate_path = "#{extension_dir}/#{file_name}"
+  if File.exist?(candidate_path)
+    full_file_path = candidate_path
+  else # rubocop:disable Style/EmptyElse
+    # We found none of the files. This is unexpected. Let's go ahead anyway, the error is going to be reported further
+    # down anyway.
+  end
+end
+
 init_function_name = "Init_#{extension_name.split('.').first}"
 
 status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)

data/lib/datadog/profiling.rb

@@ -63,6 +63,17 @@ module Datadog
       !!(profiler.send(:scheduler).running? if profiler)
     end
 
+    def self.wait_until_running(timeout_seconds: 5)
+      profiler = Datadog.send(:components).profiler
+      if profiler
+        # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+        worker = profiler.send(:worker)
+        worker.wait_until_running(timeout_seconds: timeout_seconds)
+      else
+        raise 'Profiler not enabled or available'
+      end
+    end
+
     private_class_method def self.replace_noop_allocation_count
       def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count

data/lib/datadog/tracing/sampling/matcher.rb

@@ -29,20 +29,40 @@ module Datadog
           end
         end.new
 
-        attr_reader :name, :service
+        attr_reader :name, :service, :resource, :tags
 
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name,
         #             defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
-        def initialize(name: MATCH_ALL, service: MATCH_ALL)
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
+        def initialize(name: MATCH_ALL, service: MATCH_ALL, resource: MATCH_ALL, tags: {})
           super()
           @name = name
           @service = service
+          @resource = resource
+          @tags = tags
         end
 
         def match?(trace)
-          name === trace.name && service === trace.service
+          name === trace.name && service === trace.service && resource === trace.resource && tags_match?(trace)
+        end
+
+        private
+
+        # Match against the trace tags and metrics.
+        def tags_match?(trace)
+          @tags.all? do |name, matcher|
+            tag = trace.get_tag(name)
+
+            # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
+            # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
+            # can affect exact string matching (e.g. '400' matching '400.0').
+            tag = format('%g', tag) if tag.is_a?(Numeric)
+
+            matcher === tag
+          end
         end
       end
 

data/lib/datadog/tracing/sampling/rule.rb

@@ -51,8 +51,13 @@ module Datadog
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name, defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
         # @param sample_rate [Float] Sampling rate between +[0,1]+
-        def initialize(name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL, sample_rate: 1.0)
+        def initialize(
+          name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL,
+          resource: SimpleMatcher::MATCH_ALL, tags: {}, sample_rate: 1.0
+        )
           # We want to allow 0.0 to drop all traces, but {Datadog::Tracing::Sampling::RateSampler}
           # considers 0.0 an invalid rate and falls back to 100% sampling.
           #
@@ -64,7 +69,7 @@ module Datadog
           sampler = RateSampler.new
           sampler.sample_rate = sample_rate
 
-          super(SimpleMatcher.new(name: name, service: service), sampler)
+          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler)
         end
       end
     end

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -61,6 +61,8 @@ module Datadog
             kwargs = {
               name: rule['name'],
               service: rule['service'],
+              resource: rule['resource'],
+              tags: rule['tags'],
               sample_rate: sample_rate,
             }
 

data/lib/ddtrace/version.rb

@@ -3,8 +3,8 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 21
-    PATCH = 1
+    MINOR = 22
+    PATCH = 0
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 1.21.1
+  version: 1.22.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.2.0
+        version: 7.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.2.0
+        version: 7.0.0.1.0
 - !ruby/object:Gem::Dependency
   name: datadog-ci
   requirement: !ruby/object:Gem::Requirement
@@ -296,7 +296,6 @@ files:
 - lib/datadog/core/runtime/ext.rb
 - lib/datadog/core/runtime/metrics.rb
 - lib/datadog/core/telemetry/client.rb
-- lib/datadog/core/telemetry/collector.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/ext.rb
@@ -306,17 +305,7 @@ files:
 - lib/datadog/core/telemetry/http/ext.rb
 - lib/datadog/core/telemetry/http/response.rb
 - lib/datadog/core/telemetry/http/transport.rb
-- lib/datadog/core/telemetry/v1/app_event.rb
-- lib/datadog/core/telemetry/v1/application.rb
-- lib/datadog/core/telemetry/v1/configuration.rb
-- lib/datadog/core/telemetry/v1/dependency.rb
-- lib/datadog/core/telemetry/v1/host.rb
-- lib/datadog/core/telemetry/v1/install_signature.rb
-- lib/datadog/core/telemetry/v1/integration.rb
-- lib/datadog/core/telemetry/v1/product.rb
-- lib/datadog/core/telemetry/v1/telemetry_request.rb
-- lib/datadog/core/telemetry/v2/app_client_configuration_change.rb
-- lib/datadog/core/telemetry/v2/request.rb
+- lib/datadog/core/telemetry/request.rb
 - lib/datadog/core/transport/ext.rb
 - lib/datadog/core/transport/http/adapters/net.rb
 - lib/datadog/core/transport/http/adapters/registry.rb
@@ -908,7 +897,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications

data/lib/datadog/core/telemetry/collector.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require 'etc'
-
-require_relative '../configuration/agent_settings_resolver'
-require_relative '../environment/ext'
-require_relative '../environment/platform'
-require_relative '../utils/hash'
-require_relative 'v1/application'
-require_relative 'v1/dependency'
-require_relative 'v1/host'
-require_relative 'v1/install_signature'
-require_relative 'v1/integration'
-require_relative 'v1/product'
-require_relative '../transport/ext'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Module defining methods for collecting metadata for telemetry
-      module Collector
-        include Datadog::Core::Configuration
-        using Core::Utils::Hash::Refinement
-
-        # Forms a hash of configuration key value pairs to be sent in the additional payload
-        def additional_payload
-          additional_payload_variables
-        end
-
-        # Forms a telemetry application object
-        def application
-          Telemetry::V1::Application.new(
-            env: env,
-            language_name: Datadog::Core::Environment::Ext::LANG,
-            language_version: Datadog::Core::Environment::Ext::LANG_VERSION,
-            products: products,
-            runtime_name: Datadog::Core::Environment::Ext::RUBY_ENGINE,
-            runtime_version: Datadog::Core::Environment::Ext::ENGINE_VERSION,
-            service_name: service_name,
-            service_version: service_version,
-            tracer_version: library_version
-          )
-        end
-
-        # Forms a hash of standard key value pairs to be sent in the app-started event configuration
-        def configurations
-          config = Datadog.configuration
-          hash = {
-            DD_AGENT_HOST: config.agent.host,
-            DD_AGENT_TRANSPORT: agent_transport,
-            DD_TRACE_SAMPLE_RATE: format_configuration_value(config.tracing.sampling.default_rate),
-            DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED: config.tracing.contrib.global_default_service_name.enabled
-          }
-          peer_service_mapping_str = ''
-          unless config.tracing.contrib.peer_service_mapping.empty?
-            peer_service_mapping = config.tracing.contrib.peer_service_mapping
-            peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
-          end
-          hash[:DD_TRACE_PEER_SERVICE_MAPPING] = peer_service_mapping_str
-          hash.compact!
-          hash
-        end
-
-        # Forms a telemetry app-started dependencies object
-        def dependencies
-          Gem.loaded_specs.collect do |name, loaded_gem|
-            Datadog::Core::Telemetry::V1::Dependency.new(
-              # `hash` should be used when `version` is not available
-              name: name, version: loaded_gem.version.to_s, hash: nil
-            )
-          end
-        end
-
-        # Forms a telemetry host object
-        def host
-          Telemetry::V1::Host.new(
-            container_id: Core::Environment::Container.container_id,
-            hostname: Core::Environment::Platform.hostname,
-            kernel_name: Core::Environment::Platform.kernel_name,
-            kernel_release: Core::Environment::Platform.kernel_release,
-            kernel_version: Core::Environment::Platform.kernel_version
-          )
-        end
-
-        # Forms a telemetry app-started install_signature object
-        def install_signature
-          Telemetry::V1::InstallSignature.new(
-            install_id: Datadog.configuration.dig('telemetry', 'install_id'),
-            install_type: Datadog.configuration.dig('telemetry', 'install_type'),
-            install_time: Datadog.configuration.dig('telemetry', 'install_time'),
-          )
-        end
-
-        # Forms a telemetry app-started integrations object
-        def integrations
-          Datadog.registry.map do |integration|
-            is_instrumented = instrumented?(integration)
-            is_enabled = is_instrumented && patched?(integration)
-            Telemetry::V1::Integration.new(
-              name: integration.name.to_s,
-              enabled: is_enabled,
-              version: integration_version(integration),
-              compatible: integration_compatible?(integration),
-              error: (patch_error(integration) if is_instrumented && !is_enabled),
-              auto_enabled: is_enabled ? integration_auto_instrument?(integration) : nil
-            )
-          end
-        end
-
-        # Returns the runtime ID of the current process
-        def runtime_id
-          Datadog::Core::Environment::Identity.id
-        end
-
-        # Returns the current as a UNIX timestamp in seconds
-        def tracer_time
-          Time.now.to_i
-        end
-
-        private
-
-        TARGET_OPTIONS = [
-          'ci.enabled',
-          'logger.level',
-          'profiling.advanced.code_provenance_enabled',
-          'profiling.advanced.endpoint.collection.enabled',
-          'profiling.enabled',
-          'runtime_metrics.enabled',
-          'tracing.analytics.enabled',
-          'tracing.distributed_tracing.propagation_inject_style',
-          'tracing.distributed_tracing.propagation_extract_style',
-          'tracing.enabled',
-          'tracing.log_injection',
-          'tracing.partial_flush.enabled',
-          'tracing.partial_flush.min_spans_threshold',
-          'tracing.priority_sampling',
-          'tracing.report_hostname',
-          'tracing.sampling.default_rate',
-          'tracing.sampling.rate_limit'
-        ].freeze
-
-        def additional_payload_variables
-          # Whitelist of configuration options to send in additional payload object
-          configuration = Datadog.configuration
-          options = TARGET_OPTIONS.each_with_object({}) do |option, hash|
-            split_option = option.split('.')
-            hash[option] = format_configuration_value(configuration.dig(*split_option))
-          end
-
-          # Add some more custom additional payload values here
-          options['tracing.auto_instrument.enabled'] = !defined?(Datadog::AutoInstrument::LOADED).nil?
-          options['tracing.writer_options.buffer_size'] =
-            format_configuration_value(configuration.tracing.writer_options[:buffer_size])
-          options['tracing.writer_options.flush_interval'] =
-            format_configuration_value(configuration.tracing.writer_options[:flush_interval])
-          options['logger.instance'] = configuration.logger.instance.class.to_s
-          options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
-          options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
-          options['tracing.opentracing.enabled'] = !defined?(Datadog::OpenTracer::LOADED).nil?
-          options.compact!
-          options
-        end
-
-        def format_configuration_value(value)
-          # TODO: Add float if telemetry starts accepting it
-          case value
-          when Integer, String, true, false, nil
-            value
-          else
-            value.to_s
-          end
-        end
-
-        def env
-          Datadog.configuration.env
-        end
-
-        def service_name
-          Datadog.configuration.service
-        end
-
-        def service_version
-          Datadog.configuration.version
-        end
-
-        def library_version
-          Core::Environment::Identity.tracer_version
-        end
-
-        def products
-          Telemetry::V1::Product.new(profiler: profiler, appsec: appsec)
-        end
-
-        def profiler
-          { version: library_version }
-        end
-
-        def appsec
-          { version: library_version }
-        end
-
-        def agent_transport
-          adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
-          if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
-            'UDS'
-          else
-            'TCP'
-          end
-        end
-
-        def instrumented_integrations
-          Datadog.configuration.tracing.instrumented_integrations
-        end
-
-        def instrumented?(integration)
-          instrumented_integrations.include?(integration.name)
-        end
-
-        def patched?(integration)
-          !!integration.klass.patcher.patch_successful
-        end
-
-        def integration_auto_instrument?(integration)
-          integration.klass.auto_instrument?
-        end
-
-        def integration_compatible?(integration)
-          integration.klass.class.compatible?
-        end
-
-        def integration_version(integration)
-          integration.klass.class.version ? integration.klass.class.version.to_s : nil
-        end
-
-        def patch_error(integration)
-          patch_error_result = integration.klass.patcher.patch_error_result
-          if patch_error_result.nil? # if no error occurred during patching, but integration is still not instrumented
-            desc = "Available?: #{integration.klass.class.available?}"
-            desc += ", Loaded? #{integration.klass.class.loaded?}"
-            desc += ", Compatible? #{integration.klass.class.compatible?}"
-            desc += ", Patchable? #{integration.klass.class.patchable?}"
-            desc
-          else
-            patch_error_result.compact.to_s
-          end
-        end
-      end
-    end
-  end
-end