ddtrace 1.13.0 → 1.14.0

data/lib/datadog/profiling/http_transport.rb

@@ -48,11 +48,14 @@ module Datadog
             Datadog.logger.debug('Successfully reported profiling data')
             true
           else
-            Datadog.logger.error("Failed to report profiling data: server returned unexpected HTTP #{result} status code")
+            Datadog.logger.error(
+              "Failed to report profiling data (#{config_without_api_key}): " \
+              "server returned unexpected HTTP #{result} status code"
+            )
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data: #{result}")
+          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
           false
         end
       end
@@ -128,6 +131,10 @@ module Datadog
           internal_metadata_json,
         )
       end
+
+      def config_without_api_key
+        [@exporter_configuration[0..1]].to_h
+      end
     end
   end
 end

data/lib/datadog/profiling.rb

@@ -198,6 +198,7 @@ module Datadog
       require_relative 'profiling/collectors/old_stack'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
+      require_relative 'profiling/diagnostics/environment_logger'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/old_recorder'
       require_relative 'profiling/exporter'

data/lib/datadog/tracing/component.rb

@@ -5,6 +5,7 @@ require_relative 'flush'
 require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
 require_relative 'sampling/span/sampler'
+require_relative 'diagnostics/environment_logger'
 
 module Datadog
   module Tracing
@@ -154,7 +155,7 @@ module Datadog
       end
 
       WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
-        Core::Diagnostics::EnvironmentLogger.log!(responses)
+        Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
       end
 
       # Create new lambda for writer callback,

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -90,18 +90,25 @@ module Datadog
               )
             end
 
+            #
+            # `::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver` exists from 4+ til from 6.0.x
+            #
+            # `::ActiveRecord::DatabaseConfigurations` was introduced from 6+,
+            # but from 6.1.x, it was refactored to encapsulates the resolving logic, hence removing the resolver
+            #
             def connection_resolver
-              @resolver ||= if defined?(::ActiveRecord::Base.configurations.resolve)
-                              ::ActiveRecord::DatabaseConfigurations.new(active_record_configuration)
-                            elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
-                              ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(
-                                active_record_configuration
-                              )
-                            else
-                              Contrib::ActiveRecord::Vendor::ConnectionAdapters::ConnectionSpecification::Resolver.new(
-                                active_record_configuration
-                              )
-                            end
+              @resolver ||=
+                # From 6.1+
+                if defined?(::ActiveRecord::Base.configurations.resolve)
+                  ::ActiveRecord::DatabaseConfigurations.new(active_record_configuration)
+                # From 4+ to 6.0.x
+                elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
+                  ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(active_record_configuration)
+                else
+                  Contrib::ActiveRecord::Vendor::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+                    active_record_configuration
+                  )
+                end
             end
 
             def resolve_connection_key(key)

data/lib/datadog/tracing/contrib/active_record/utils.rb

@@ -113,7 +113,7 @@ module Datadog
 
           # @return [Hash]
           def self.db_config(connection_pool)
-            if ::Rails::VERSION::MAJOR >= 6 && ::Rails::VERSION::MINOR >= 1
+            if connection_pool.respond_to? :db_config
               connection_pool.db_config.configuration_hash
             else
               connection_pool.spec.config

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

@@ -24,123 +24,120 @@ module Datadog
             require 'json'
             require_relative 'quantize'
 
-            patch_elasticsearch_transport_client
+            transport_module::Client.prepend(Client)
           end
 
           SELF_DEPRECATION_ONLY_ONCE = Core::Utils::OnlyOnce.new
 
-          # rubocop:disable Metrics/MethodLength
-          # rubocop:disable Metrics/AbcSize
-          # rubocop:disable Metrics/CyclomaticComplexity
-          # rubocop:disable Metrics/PerceivedComplexity
-          def patch_elasticsearch_transport_client
-            # rubocop:disable Metrics/BlockLength
-            transport_module::Client.class_eval do
-              alias_method :perform_request_without_datadog, :perform_request
-              remove_method :perform_request
-
-              def perform_request(*args)
-                # DEV-2.0: Remove this access, as `Client#self` in this context is not exposed to the user
-                # since `elasticsearch` v8.0.0. In contrast, `Client#transport` is always available across
-                # all `elasticsearch` gem versions and should be used instead.
-                service = Datadog.configuration_for(self, :service_name)
-
-                if service
-                  SELF_DEPRECATION_ONLY_ONCE.run do
-                    Datadog.logger.warn(
-                      'Providing configuration though the Elasticsearch client object is deprecated.' \
-                      'Configure the `client#transport` object instead: ' \
-                      'Datadog.configure_onto(client.transport, service_name: service_name, ...)'
+          # Patches Elasticsearch::Transport::Client module
+          module Client
+            # rubocop:disable Metrics/MethodLength
+            # rubocop:disable Metrics/AbcSize
+            def perform_request(*args)
+              # DEV-2.0: Remove this access, as `Client#self` in this context is not exposed to the user
+              # since `elasticsearch` v8.0.0. In contrast, `Client#transport` is always available across
+              # all `elasticsearch` gem versions and should be used instead.
+              service = Datadog.configuration_for(self, :service_name)
+
+              if service
+                SELF_DEPRECATION_ONLY_ONCE.run do
+                  Datadog.logger.warn(
+                    'Providing configuration though the Elasticsearch client object is deprecated.' \
+                    'Configure the `client#transport` object instead: ' \
+                    'Datadog.configure_onto(client.transport, service_name: service_name, ...)'
+                  )
+                end
+              end
+
+              # `Client#transport` is most convenient object both this integration and the library
+              # user have shared access to across all `elasticsearch` versions.
+              #
+              # `Client#self` in this context is an internal object that the library user
+              # does not have access to since `elasticsearch` v8.0.0.
+              service ||= Datadog.configuration_for(transport, :service_name) || datadog_configuration[:service_name]
+
+              method = args[0]
+              path = args[1]
+              params = args[2]
+              body = args[3]
+              full_url = URI.parse(path)
+              url = full_url.path
+              response = nil
+
+              Tracing.trace(Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_QUERY, service: service) do |span|
+                begin
+                  connection = transport.connections.first
+                  host = connection.host[:host] if connection
+                  port = connection.host[:port] if connection
+
+                  if datadog_configuration[:peer_service]
+                    span.set_tag(
+                      Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                      datadog_configuration[:peer_service]
                     )
                   end
-                end
 
-                # `Client#transport` is most convenient object both this integration and the library
-                # user have shared access to across all `elasticsearch` versions.
-                #
-                # `Client#self` in this context is an internal object that the library user
-                # does not have access to since `elasticsearch` v8.0.0.
-                service ||= Datadog.configuration_for(transport, :service_name) || datadog_configuration[:service_name]
-
-                method = args[0]
-                path = args[1]
-                params = args[2]
-                body = args[3]
-                full_url = URI.parse(path)
-
-                url = full_url.path
-                response = nil
-
-                Tracing.trace(Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_QUERY, service: service) do |span|
-                  begin
-                    connection = transport.connections.first
-                    host = connection.host[:host] if connection
-                    port = connection.host[:port] if connection
-
-                    if datadog_configuration[:peer_service]
-                      span.set_tag(
-                        Tracing::Metadata::Ext::TAG_PEER_SERVICE,
-                        datadog_configuration[:peer_service]
-                      )
-                    end
-
-                    span.span_type = Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_TYPE_QUERY
-
-                    span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                    span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
-                    span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
-
-                    span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
-
-                    # load JSON for the following fields unless they're already strings
-                    params = JSON.generate(params) if params && !params.is_a?(String)
-                    body = JSON.generate(body) if body && !body.is_a?(String)
-
-                    span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host) if host
-
-                    # 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::Tracing::Contrib::Elasticsearch::Ext::TAG_METHOD, method)
-                    span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_URL, url)
-                    span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_PARAMS, params) if params
-                    if body
-                      quantize_options = datadog_configuration[:quantize]
-                      quantized_body = Datadog::Tracing::Contrib::Elasticsearch::Quantize.format_body(
-                        body,
-                        quantize_options
-                      )
-                      span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_BODY, quantized_body)
-                    end
-                    span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, host) if host
-                    span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, port) if port
-
-                    quantized_url = Datadog::Tracing::Contrib::Elasticsearch::Quantize.format_url(url)
-                    span.resource = "#{method} #{quantized_url}"
-                    Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-                  rescue StandardError => e
-                    Datadog.logger.error(e.message)
-                  ensure
-                    # the call is still executed
-                    response = perform_request_without_datadog(*args)
-                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                  span.span_type = Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_TYPE_QUERY
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
+                  span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+                  span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host) if host
+
+                  # 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::Tracing::Contrib::Elasticsearch::Ext::TAG_METHOD, method)
+                  tag_params(params, span)
+                  tag_body(body, span)
+                  span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_URL, url)
+                  span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, host) if host
+                  span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, port) if port
+
+                  quantized_url = Datadog::Tracing::Contrib::Elasticsearch::Quantize.format_url(url)
+                  span.resource = "#{method} #{quantized_url}"
+                  Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+                rescue StandardError => e
+                  Datadog.logger.error(e.message)
+                ensure
+                  # the call is still executed
+                  response = super
+                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
                 end
-                response
               end
+              response
+            end
 
-              def datadog_configuration
-                Datadog.configuration.tracing[:elasticsearch]
-              end
+            def tag_params(params, span)
+              return unless params
+
+              params = JSON.generate(params) unless params.is_a?(String)
+              span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_PARAMS, params)
+            end
+
+            def tag_body(body, span)
+              return unless body
+
+              body = JSON.generate(body) unless body.is_a?(String)
+              quantize_options = datadog_configuration[:quantize]
+              quantized_body = Datadog::Tracing::Contrib::Elasticsearch::Quantize.format_body(
+                body,
+                quantize_options
+              )
+              span.set_tag(Datadog::Tracing::Contrib::Elasticsearch::Ext::TAG_BODY, quantized_body)
+            end
+
+            def datadog_configuration
+              Datadog.configuration.tracing[:elasticsearch]
             end
-            # rubocop:enable Metrics/BlockLength
           end
           # rubocop:enable Metrics/MethodLength
           # rubocop:enable Metrics/AbcSize
-          # rubocop:enable Metrics/CyclomaticComplexity
-          # rubocop:enable Metrics/PerceivedComplexity
 
           # `Elasticsearch` namespace renamed to `Elastic` in version 8.0.0 of the transport gem:
           # @see https://github.com/elastic/elastic-transport-ruby/commit/ef804cbbd284f2a82d825221f87124f8b5ff823c

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -3,6 +3,7 @@ require 'uri'
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../utils/quantization/http'
 
 module Datadog
   module Tracing
@@ -79,8 +80,10 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
-
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, request.path)
+              span.set_tag(
+                Tracing::Metadata::Ext::HTTP::TAG_URL,
+                Contrib::Utils::Quantization::HTTP.url(request.path, { query: { exclude: :all } })
+              )
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request.method)
 
               host, port = host_and_port(request)

data/lib/datadog/tracing/contrib/lograge/instrumentation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/logging/ext'
-
 module Datadog
   module Tracing
     module Contrib
@@ -23,21 +21,7 @@ module Datadog
               # Retrieves trace information for current thread
               correlation = Tracing.correlation
               # merge original lambda with datadog context
-
-              datadog_trace_log_hash = {
-                # Adds IDs as tags to log output
-                dd: {
-                  # To preserve precision during JSON serialization, use strings for large numbers
-                  trace_id: correlation.trace_id.to_s,
-                  span_id: correlation.span_id.to_s,
-                  env: correlation.env.to_s,
-                  service: correlation.service.to_s,
-                  version: correlation.version.to_s
-                },
-                ddsource: Core::Logging::Ext::DD_SOURCE
-              }
-
-              datadog_trace_log_hash.merge(original_custom_options)
+              correlation.to_h.merge(original_custom_options)
             end
           end
         end

data/lib/datadog/tracing/contrib/rails/log_injection.rb

@@ -8,9 +8,12 @@ module Datadog
           module_function
 
           # Use `app.config.log_tags` to inject propagation tags into the default Rails logger.
-          def configure_log_tags(app)
-            app.config.log_tags ||= [] # Can be nil, we initialized it if so
-            app.config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
+          def configure_log_tags(app_config)
+            # When using SemanticLogger, app_config.log_tags could be a Hash and should not be modified here
+            return unless app_config.log_tags.nil? || app_config.log_tags.respond_to?(:<<)
+
+            app_config.log_tags ||= [] # Can be nil, we initialized it if so
+            app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
           rescue StandardError => e
             Datadog.logger.warn(
               "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"

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

@@ -41,7 +41,7 @@ module Datadog
               # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
               add_middleware(app) if Datadog.configuration.tracing[:rails][:middleware]
 
-              Rails::LogInjection.configure_log_tags(app)
+              Rails::LogInjection.configure_log_tags(app.config)
             end
           end
 

data/lib/datadog/tracing/contrib/semantic_logger/instrumentation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/logging/ext'
-
 module Datadog
   module Tracing
     module Contrib
@@ -23,25 +21,10 @@ module Datadog
 
               # Retrieves trace information for current thread
               correlation = Tracing.correlation
-              # merge original lambda with datadog context
-
-              datadog_trace_log_hash = {
-                # Adds IDs as tags to log output
-                dd: {
-                  # To preserve precision during JSON serialization, use strings for large numbers
-                  trace_id: correlation.trace_id.to_s,
-                  span_id: correlation.span_id.to_s,
-                  env: correlation.env.to_s,
-                  service: correlation.service.to_s,
-                  version: correlation.version.to_s
-                },
-                ddsource: Core::Logging::Ext::DD_SOURCE
-              }
 
-              # # if the user already has conflicting log_tags
-              # # we want them to clobber ours, because we should allow them to override
-              # # if needed.
-              log.named_tags = datadog_trace_log_hash.merge(original_named_tags)
+              # if the user already has conflicting log_tags
+              # we want them to clobber ours, because we should allow them to override if needed.
+              log.named_tags = correlation.to_h.merge(original_named_tags)
               super(log, message, progname, &block)
             end
           end

data/lib/datadog/tracing/contrib/utils/quantization/http.rb

@@ -134,18 +134,18 @@ module Datadog
                  (?:"|%22)?
               )
               (?: # common keys
-                 (?:old_?|new_?)?p(?:ass)?w(?:or)?d(?:1|2)? # pw, password variants
-                |pass(?:_?phrase)?  # pass, passphrase variants
+                 (?:old[-_]?|new_?)?p(?:ass)?w(?:or)?d(?:1|2)? # pw, password variants
+                |pass(?:[-_]?phrase)?  # pass, passphrase variants
                 |secret
                 |(?: # key, key_id variants
-                     api_?
-                    |private_?
-                    |public_?
-                    |access_?
-                    |secret_?
-                 )key(?:_?id)?
+                     api[-_]?
+                    |private[-_]?
+                    |public[-_]?
+                    |access[-_]?
+                    |secret[-_]?
+                 )key(?:[-_]?id)?
                 |token
-                |consumer_?(?:id|key|secret)
+                |consumer[-_]?(?:id|key|secret)
                 |sign(?:ed|ature)?
                 |auth(?:entication|orization)?
               )

data/lib/datadog/tracing/contrib.rb

@@ -58,6 +58,7 @@ require_relative 'contrib/kafka/integration'
 require_relative 'contrib/lograge/integration'
 require_relative 'contrib/mongodb/integration'
 require_relative 'contrib/mysql2/integration'
+require_relative 'contrib/opensearch/integration'
 require_relative 'contrib/pg/integration'
 require_relative 'contrib/presto/integration'
 require_relative 'contrib/qless/integration'

data/lib/datadog/tracing/correlation.rb

@@ -1,5 +1,6 @@
 require_relative 'utils'
 require_relative 'metadata/ext'
+require_relative '../core/logging/ext'
 
 module Datadog
   module Tracing
@@ -14,6 +15,7 @@ module Datadog
         LOG_ATTR_SPAN_ID = 'dd.span_id'.freeze
         LOG_ATTR_TRACE_ID = 'dd.trace_id'.freeze
         LOG_ATTR_VERSION = 'dd.version'.freeze
+        LOG_ATTR_SOURCE = 'ddsource'.freeze
 
         attr_reader \
           :env,
@@ -58,6 +60,23 @@ module Datadog
           @version = Core::Utils::SafeDup.frozen_dup(version || Datadog.configuration.version)
         end
 
+        def to_h
+          @to_h ||= {
+            # Adds IDs as tags to log output
+            dd: {
+              # To preserve precision during JSON serialization, use strings for large numbers
+              env: env.to_s,
+              service: service.to_s,
+              version: version.to_s,
+              trace_id: trace_id.to_s,
+              span_id: span_id.to_s
+            },
+            ddsource: Core::Logging::Ext::DD_SOURCE
+          }
+        end
+
+        # This method (#to_log_format) implements an algorithm by prefixing keys for nested values
+        # but the algorithm makes the constants implicit. Hence, we use it for validation during test.
         def to_log_format
           @log_format ||= begin
             attributes = []
@@ -66,6 +85,7 @@ module Datadog
             attributes << "#{LOG_ATTR_VERSION}=#{version}" unless version.nil?
             attributes << "#{LOG_ATTR_TRACE_ID}=#{trace_id}"
             attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes << "#{LOG_ATTR_SOURCE}=#{Core::Logging::Ext::DD_SOURCE}"
             attributes.join(' ')
           end
         end