ddtrace 1.13.1 → 1.14.0

data/lib/datadog/profiling/diagnostics/environment_logger.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'json'
+require 'rbconfig'
+require_relative '../../core/diagnostics/environment_logger'
+
+module Datadog
+  module Profiling
+    module Diagnostics
+      # Collects and logs Profiling diagnostic information
+      module EnvironmentLogger
+        extend Core::Diagnostics::EnvironmentLogging
+
+        def self.collect_and_log!
+          log_once! do
+            data = EnvironmentCollector.collect_config!
+            log_configuration!('PROFILING', data.to_json)
+          end
+        rescue => e
+          logger.warn("Failed to collect profiling environment information: #{e} Location: #{Array(e.backtrace).first}")
+        end
+      end
+
+      # Collects environment information for Profiling diagnostic logging
+      module EnvironmentCollector
+        def self.collect_config!(*args)
+          {
+            profiling_enabled: profiling_enabled
+          }
+        end
+
+        def self.profiling_enabled
+          !!Datadog.configuration.profiling.enabled
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/exporter.rb

@@ -23,14 +23,14 @@ module Datadog
         :time_provider,
         :last_flush_finish_at,
         :created_at,
-        :no_signals_workaround_enabled
+        :internal_metadata
 
       public
 
       def initialize(
         pprof_recorder:,
         code_provenance_collector:,
-        no_signals_workaround_enabled:,
+        internal_metadata:,
         minimum_duration_seconds: PROFILE_DURATION_THRESHOLD_SECONDS,
         time_provider: Time
       )
@@ -40,7 +40,7 @@ module Datadog
         @time_provider = time_provider
         @last_flush_finish_at = nil
         @created_at = time_provider.now.utc
-        @no_signals_workaround_enabled = no_signals_workaround_enabled
+        @internal_metadata = internal_metadata
       end
 
       def flush
@@ -64,7 +64,7 @@ module Datadog
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
           tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
-          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          internal_metadata: internal_metadata,
         )
       end
 

data/lib/datadog/profiling/flush.rb

@@ -27,7 +27,7 @@ module Datadog
         code_provenance_file_name:,
         code_provenance_data:,
         tags_as_array:,
-        no_signals_workaround_enabled:
+        internal_metadata:
       )
         @start = start
         @finish = finish
@@ -36,9 +36,7 @@ module Datadog
         @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
         @tags_as_array = tags_as_array
-        @internal_metadata_json = JSON.fast_generate(
-          no_signals_workaround_enabled: (!!no_signals_workaround_enabled).to_s,
-        )
+        @internal_metadata_json = JSON.fast_generate(internal_metadata.map { |k, v| [k, v.to_s] }.to_h)
       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/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/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/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