datadog 2.7.1 → 2.18.0

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Patch to add tracing to Karafka::Messages::Messages
+        module MessagesPatch
+          def configuration
+            Datadog.configuration.tracing[:karafka]
+          end
+
+          def propagation
+            @propagation ||= Contrib::Karafka::Distributed::Propagation.new
+          end
+
+          # `each` is the most popular access point to Karafka messages,
+          # but not the only one
+          #  Other access patterns do not have a straightforward tracing avenue
+          # (e.g. `my_batch_operation messages.payloads`)
+          # @see https://github.com/karafka/karafka/blob/b06d1f7c17818e1605f80c2bb573454a33376b40/README.md?plain=1#L29-L35
+          def each(&block)
+            @messages_array.each do |message|
+              if configuration[:distributed_tracing]
+                headers = if message.metadata.respond_to?(:raw_headers)
+                            message.metadata.raw_headers
+                          else
+                            message.metadata.headers
+                          end
+                trace_digest = Karafka.extract(headers)
+                Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
+              end
+
+              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
+                span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
+                span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                span.resource = message.topic
+
+                yield message
+              end
+            end
+          end
+        end
+
+        # Patcher enables patching of 'karafka' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'monitor'
+
+            ::Karafka::Instrumentation::Monitor.prepend(Monitor)
+            ::Karafka::Messages::Messages.prepend(MessagesPatch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'karafka/integration'
+require_relative 'karafka/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `Karafka` integration public API
+      module Karafka
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('karafka') do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = Karafka::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -20,10 +20,12 @@ module Datadog
 
           # patch applies our patch
           def patch
+            # First check Lograge logger directly for when keep_original_rails_log option is used
+            used_logger = ::Lograge.logger || ::Lograge::LogSubscribers::ActionController.logger
+
             # ActiveSupport::TaggedLogging is the default Rails logger since Rails 5
             if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
-                ::Lograge::LogSubscribers::ActionController
-                    .logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
+                used_logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
               Datadog.logger.warn(
                 'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
                   'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \

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

@@ -48,6 +48,14 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            # Serializes the command to JSON format, which is the desired format for the agent and Datadog UI.
+            # Setting this to false is deprecated and does not have any advantages.
+            option :json_command do |o|
+              o.type :bool
+              o.env Ext::ENV_JSON_COMMAND
+              o.default false
+            end
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_MONGO_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MONGO_ANALYTICS_SAMPLE_RATE'
+          ENV_JSON_COMMAND = 'DD_TRACE_MONGO_JSON_COMMAND'
           DEFAULT_PEER_SERVICE_NAME = 'mongodb'
           SPAN_COMMAND = 'mongo.cmd'
           SPAN_TYPE_COMMAND = 'mongodb'

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

@@ -17,6 +17,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :mongo, auto_patch: true
+          def self.gem_name
+            'mongo'
+          end
 
           def self.version
             Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
@@ -30,7 +32,7 @@ module Datadog
 
             # build a quantized Query using the Parser module
             query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
-            serialized_query = query.to_s
+            serialized_query = serialize_query(query)
 
             if datadog_configuration[:peer_service]
               span.set_tag(
@@ -109,6 +111,21 @@ module Datadog
 
           private
 
+          def serialize_query(query)
+            if datadog_configuration[:json_command]
+              query.to_json
+            else
+              # Incorrect Hash#to_s serialization. The Mongo command should only be encoded as JSON.
+              # This code path should be removed, and is only kept to avoid a breaking change.
+              Datadog::Core.log_deprecation(key: :mongo_json_command) do
+                'MongoDB integration: `json_command: false` causes invalid command serialization. '\
+                'Use `json_command: true` or `DD_TRACE_MONGO_JSON_COMMAND=1` instead.'
+              end
+
+              query.to_s
+            end
+          end
+
           def get_span(event)
             Thread.current[:datadog_mongo_span] \
               && Thread.current[:datadog_mongo_span][event.request_id]

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

@@ -46,6 +46,23 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            option :resource_pattern do |o|
+              o.type :string
+              o.env Ext::ENV_RESOURCE_PATTERN
+              o.default Ext::DEFAULT_RESOURCE_PATTERN
+              o.setter do |value|
+                next value if Ext::VALID_RESOURCE_PATTERNS.include?(value)
+
+                Datadog.logger.warn(
+                  "Invalid resource pattern: #{value}. " \
+                  "Supported values are: #{Ext::VALID_RESOURCE_PATTERNS.join(' | ')}. " \
+                  "Using default value: #{Ext::DEFAULT_RESOURCE_PATTERN}."
+                )
+
+                Ext::DEFAULT_RESOURCE_PATTERN
+              end
+            end
           end
         end
       end

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

@@ -13,6 +13,15 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_OPENSEARCH_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_OPENSEARCH_ANALYTICS_SAMPLE_RATE'
+          ENV_RESOURCE_PATTERN = 'DD_TRACE_OPENSEARCH_RESOURCE_PATTERN'
+          ABSOLUTE_RESOURCE_PATTERN = 'absolute'
+          RELATIVE_RESOURCE_PATTERN = 'relative'
+          VALID_RESOURCE_PATTERNS = [
+            ABSOLUTE_RESOURCE_PATTERN,
+            RELATIVE_RESOURCE_PATTERN
+          ].freeze
+          # Default should be changed to RELATIVE in 3.0 to match the Elasticsearch integration
+          DEFAULT_RESOURCE_PATTERN = ABSOLUTE_RESOURCE_PATTERN
           DEFAULT_PEER_SERVICE_NAME = 'opensearch'
           SPAN_QUERY = 'opensearch.query'
           SPAN_TYPE_QUERY = 'opensearch'

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

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :opensearch, auto_patch: true
+          def self.gem_name
+            'opensearch-ruby'
+          end
 
           def self.version
             Gem.loaded_specs['opensearch-ruby'] \

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

@@ -77,7 +77,11 @@ module Datadog
                   span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host) if host
 
                   # Define span resource
-                  quantized_url = OpenSearch::Quantize.format_url(url)
+                  quantized_url = if datadog_configuration[:resource_pattern] == Ext::RELATIVE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url.path)
+                                  else # Default to Ext::ABSOLUTE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url)
+                                  end
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e

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

@@ -20,8 +20,11 @@ module Datadog
         # @public_api
         module CommonMethods
           attr_accessor \
-            :patch_error_result,
-            :patch_successful
+            :patch_error_result
+
+          def patch_successful
+            !!@patch_successful
+          end
 
           def patch_name
             self.class != Class && self.class != Module ? self.class.name : name

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

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :presto
+          def self.gem_name
+            'presto-client'
+          end
 
           def self.version
             Gem.loaded_specs['presto-client'] && Gem.loaded_specs['presto-client'].version

data/lib/datadog/tracing/contrib/rack/header_collection.rb

@@ -31,7 +31,17 @@ module Datadog
           end
 
           def self.to_rack_header(name)
-            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+            key = name.to_s.upcase.gsub(/[-\s]/, '_')
+            case key
+            when 'CONTENT_TYPE', 'CONTENT_LENGTH'
+              # NOTE: The Rack spec says:
+              # > The environment must not contain the keys HTTP_CONTENT_TYPE or HTTP_CONTENT_LENGTH
+              # > (use the versions without HTTP_).
+              # See https://github.com/rack/rack/blob/e217a399eb116362710aac7c5b8dc691ea2189b3/SPEC.rdoc?plain=1#L119-L121
+              key
+            else
+              "HTTP_#{key}"
+            end
           end
         end
       end

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

@@ -3,7 +3,7 @@
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'
-require_relative '../rails/utils'
+require_relative '../../../core/contrib/rails/utils'
 
 module Datadog
   module Tracing
@@ -33,7 +33,7 @@ module Datadog
           # enabled by rails integration so should only auto instrument
           # if detected that it is being used without rails
           def auto_instrument?
-            !Contrib::Rails::Utils.railtie_supported?
+            !Core::Contrib::Rails::Utils.railtie_supported?
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -43,7 +43,7 @@ module Datadog
             # so that all spans will be added to the distributed trace.
             if configuration[:distributed_tracing]
               trace_digest = Contrib::HTTP.extract(env)
-              Tracing.continue_trace!(trace_digest)
+              Tracing.continue_trace!(trace_digest) if trace_digest
             end
 
             TraceProxyMiddleware.call(env, configuration) do

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -17,7 +17,7 @@ module Datadog
 
           module_function
 
-          def get_request_start(env, now = Time.now.utc)
+          def get_request_start(env, now = Core::Utils::Time.now.utc)
             header = env[REQUEST_START] || env[QUEUE_START]
             return unless header
 

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

@@ -9,7 +9,7 @@ require_relative '../active_support/integration'
 require_relative '../grape/endpoint'
 require_relative '../lograge/integration'
 require_relative 'ext'
-require_relative 'utils'
+require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/integration'
 
 module Datadog
@@ -41,7 +41,7 @@ module Datadog
               # being executed, but here we know better, get it from Rails config.
               # Don't set this if service has been explicitly provided by the user.
               if datadog_config.service_without_fallback.nil?
-                datadog_config.service = rails_config[:service_name] || Utils.app_name
+                datadog_config.service = rails_config[:service_name] || Core::Contrib::Rails::Utils.app_name
               end
 
               activate_rack!(datadog_config, rails_config)

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

@@ -6,7 +6,7 @@ require_relative 'framework'
 require_relative 'log_injection'
 require_relative 'middlewares'
 require_relative 'runner'
-require_relative 'utils'
+require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/patcher'
 
 module Datadog

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

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :rest_client
+          def self.gem_name
+            'rest-client'
+          end
 
           def self.version
             Gem.loaded_specs['rest-client'] && Gem.loaded_specs['rest-client'].version

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -25,10 +25,12 @@ module Datadog
               return super(&block) unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
-                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                if Tracing::Distributed::PropagationPolicy.enabled?(
+                  global_config: datadog_configuration,
+                  trace: trace
+                )
+                  Contrib::HTTP.inject(trace, processed_headers)
                 end
-                Contrib::HTTP.inject(trace, processed_headers) if datadog_configuration[:distributed_tracing]
 
                 super(&block)
               end

data/lib/datadog/tracing/contrib/sidekiq/client_tracer.rb

@@ -24,7 +24,12 @@ module Datadog
             resource = job_resource(job)
 
             Datadog::Tracing.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span, trace_op|
-              Sidekiq.inject(trace_op, job) if configuration[:distributed_tracing]
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: configuration,
+                trace: trace_op
+              )
+                Sidekiq.inject(trace_op, job)
+              end
 
               span.resource = resource
 

data/lib/datadog/tracing/contrib/sidekiq/distributed/propagation.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../../distributed/fetcher'
 require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/propagation_policy'
 require_relative '../../../distributed/b3_multi'
 require_relative '../../../distributed/b3_single'
 require_relative '../../../distributed/datadog'
@@ -31,6 +32,8 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
                 },
                 propagation_style_inject: propagation_style_inject,

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

@@ -13,6 +13,7 @@ module Datadog
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_SIDEKIQ_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SIDEKIQ_ANALYTICS_SAMPLE_RATE'
           SERVICE_NAME = 'sidekiq'
+          SIDEKIQ_8_SECONDS_PER_INTEGER = 0.001 # Sidekiq 8 uses integer epoch milliseconds, rather than epoch floats
           SPAN_PUSH = 'sidekiq.push'
           SPAN_JOB = 'sidekiq.job'
           SPAN_JOB_FETCH = 'sidekiq.job_fetch'

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -22,7 +22,7 @@ module Datadog
             @quantize = options[:quantize] || configuration[:quantize]
           end
 
-          def call(worker, job, queue)
+          def call(worker, job, queue) # rubocop:disable Metrics/MethodLength
             resource = job_resource(job)
 
             if @distributed_tracing
@@ -61,7 +61,10 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
               span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
               span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
-              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
+
+              enqueued_at = job['enqueued_at']
+              enqueued_at *= Ext::SIDEKIQ_8_SECONDS_PER_INTEGER if enqueued_at.is_a?(Integer)
+              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Core::Utils::Time.now.utc.to_f - enqueued_at.to_f))
 
               args = job['args']
               if args && !args.empty?

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

@@ -21,9 +21,14 @@ module Datadog
         end
 
         def self.set_peer_service!(span, sources)
+          config = Datadog.configuration.tracing.contrib
+
+          # If `peer_service_defaults` is disabled, we only read peer service from an explicitly set `peer.service` tag
+          sources = Datadog::Tracing::Contrib::SpanAttributeSchema::REFLEXIVE_SOURCES unless config.peer_service_defaults
+
           # Acquire all peer.service values as well as any potential remapping
           peer_service_val, peer_service_source = set_peer_service_from_source(span, sources)
-          remap_val = Datadog.configuration.tracing.contrib.peer_service_mapping[peer_service_val]
+          remap_val = config.peer_service_mapping[peer_service_val]
 
           # Only continue to setting peer.service if actual source is found
           return false unless peer_service_source

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Miscellaneous support methods to aid in the creation of integrations.
+      module Support
+        module_function
+
+        # Checks if a constant is loaded in a module, handling autoloaded constants correctly.
+        #
+        # This method is particularly useful when you need to check if a constant is fully loaded,
+        # not just defined. It handles the special case of autoloaded constants, which return
+        # non-nil for `defined?` even when they haven't been loaded yet.
+        #
+        # @param base_module [Module] the module to check for the constant
+        # @param constant [Symbol] the name of the constant to check
+        # @return [Boolean] true if the constant has been loaded, false otherwise
+        def fully_loaded?(base_module, constant)
+          # Autoload constants return `constant` for `defined?`, but that doesn't mean they are loaded...
+          base_module.const_defined?(constant) &&
+            # ... to check that we need to call `autoload?`. If it returns `nil`, it's loaded.
+            base_module.autoload?(constant).nil?
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -55,6 +55,7 @@ require_relative 'contrib/httpclient/integration'
 require_relative 'contrib/httprb/integration'
 require_relative 'contrib/integration'
 require_relative 'contrib/kafka/integration'
+require_relative 'contrib/karafka'
 require_relative 'contrib/lograge/integration'
 require_relative 'contrib/mongodb/integration'
 require_relative 'contrib/mysql2/integration'

data/lib/datadog/tracing/correlation.rb

@@ -94,8 +94,15 @@ module Datadog
       end
 
       def format_trace_id(trace_id)
-        if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
-            !Tracing::Utils::TraceId.to_high_order(trace_id).zero?
+        if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled
+          format_trace_id_128(trace_id)
+        else
+          Tracing::Utils::TraceId.to_low_order(trace_id).to_s
+        end
+      end
+
+      def format_trace_id_128(trace_id)
+        if !Tracing::Utils::TraceId.to_high_order(trace_id).zero?
           Kernel.format('%032x', trace_id)
         else
           Tracing::Utils::TraceId.to_low_order(trace_id).to_s

data/lib/datadog/tracing/distributed/b3_multi.rb

@@ -55,7 +55,7 @@ module Datadog
           span_id = Helpers.parse_hex_id(fetcher[@span_id_key])
 
           # Return early if this propagation is not valid
-          return if span_id.nil? || span_id <= 0 || span_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if span_id.nil? || span_id <= 0 || span_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
           sampling_priority = Helpers.parse_decimal_id(fetcher[@sampled_key])

data/lib/datadog/tracing/distributed/b3_single.rb

@@ -54,7 +54,7 @@ module Datadog
 
           span_id = Helpers.parse_hex_id(parts[1]) if parts.length > 1
           # Return early if this propagation is not valid
-          return if span_id.nil? || span_id <= 0 || span_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if span_id.nil? || span_id <= 0 || span_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           sampling_priority = Helpers.parse_decimal_id(parts[2]) if parts.length > 2