ddtrace 1.14.0 → 1.16.2

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

@@ -3,6 +3,7 @@ require_relative 'configuration/resolver'
 require_relative 'ext'
 require_relative 'quantize'
 require_relative 'tags'
+require_relative 'trace_middleware'
 
 module Datadog
   module Tracing
@@ -17,31 +18,11 @@ module Datadog
           # InstanceMethods - implementing instrumentation
           module InstanceMethods
             def call(*args, &block)
-              show_command_args = command_args?
-
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                span.resource = get_command(args, show_command_args)
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-
-                super
-              end
+              TraceMiddleware.call(self, args[0], service_name, command_args?) { super }
             end
 
             def call_pipeline(*args, &block)
-              show_command_args = command_args?
-
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                commands = get_pipeline_commands(args, show_command_args)
-                span.resource = commands.any? ? commands.join("\n") : '(none)'
-                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-
-                super
-              end
+              TraceMiddleware.call_pipelined(self, args[0].commands, service_name, command_args?) { super }
             end
 
             private
@@ -59,22 +40,6 @@ module Datadog
                 datadog_configuration[:service_name]
             end
 
-            def get_command(args, show_command_args)
-              if show_command_args
-                Contrib::Redis::Quantize.format_command_args(*args)
-              else
-                Contrib::Redis::Quantize.get_verb(*args)
-              end
-            end
-
-            def get_pipeline_commands(args, show_command_args)
-              if show_command_args
-                args[0].commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-              else
-                args[0].commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
-              end
-            end
-
             def datadog_configuration
               Datadog.configuration.tracing[:redis, options]
             end

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -12,7 +12,7 @@ module Datadog
         # Tags handles generic common tags assignment.
         module Tags
           class << self
-            def set_common_tags(client, span, show_command_args)
+            def set_common_tags(client, span, raw_command)
               if datadog_configuration[:peer_service]
                 span.set_tag(
                   Tracing::Metadata::Ext::TAG_PEER_SERVICE,
@@ -20,6 +20,11 @@ module Datadog
                 )
               end
 
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 
@@ -37,7 +42,7 @@ module Datadog
 
               span.set_tag Ext::TAG_DATABASE_INDEX, client.db.to_s
               span.set_tag Ext::TAG_DB, client.db
-              span.set_tag Ext::TAG_RAW_COMMAND, span.resource if show_command_args
+              span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb

@@ -9,55 +9,68 @@ module Datadog
       module Redis
         # Instrumentation for Redis 5+
         module TraceMiddleware
-          def call(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              resource = get_command(commands, datadog_configuration[:command_args])
+          # Instruments {RedisClient::ConnectionMixin#call}.
+          def call(command, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call(redis_config, command, config[:service_name], config[:command_args]) { super }
+          end
+
+          # Instruments {RedisClient::ConnectionMixin#call_pipelined}.
+          def call_pipelined(commands, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call_pipelined(redis_config, commands, config[:service_name], config[:command_args]) { super }
+          end
 
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = resource
+          class << self
+            def call(client, command, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_command(command, true)
+                span.resource = command_args ? raw_command : get_command(command, false)
 
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
 
-              super
+                yield
+              end
             end
-          end
 
-          def call_pipelined(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              pipelined_commands = get_pipeline_commands(commands, datadog_configuration[:command_args])
+            def call_pipelined(client, commands, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_pipeline_commands(commands, true)
+                span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
 
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = pipelined_commands.join("\n")
-              span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, pipelined_commands.length
+                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
 
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
 
-              super
+                yield
+              end
             end
-          end
 
-          private
+            private
 
-          def get_command(commands, boolean)
-            if boolean
-              Contrib::Redis::Quantize.format_command_args(commands)
-            else
-              Contrib::Redis::Quantize.get_verb(commands)
+            # Quantizes a single Redis command
+            def get_command(command, command_args)
+              if command_args
+                Contrib::Redis::Quantize.format_command_args(command)
+              else
+                Contrib::Redis::Quantize.get_verb(command)
+              end
             end
-          end
 
-          def get_pipeline_commands(commands, boolean)
-            if boolean
-              commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-            else
-              commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+            # Quantizes a multi-command Redis pipeline execution
+            def get_pipeline_commands(commands, command_args)
+              list = if command_args
+                       commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+                     else
+                       commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+                     end
+
+              list.empty? ? '(none)' : list.join("\n")
             end
           end
 
+          private
+
           def resolve(redis_config)
             custom = redis_config.custom[:datadog] || {}
 

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

@@ -33,7 +33,7 @@ module Datadog
             option :service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
           end
         end

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

@@ -41,6 +41,11 @@ module Datadog
                 )
               end
 
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)

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

@@ -49,6 +49,11 @@ module Datadog
             end
 
             def set_common_tags(span, db)
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
 

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

@@ -33,7 +33,7 @@ module Datadog
             option :service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
             option :tag_body, default: false, type: :bool
           end

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

@@ -40,7 +40,7 @@ module Datadog
             option :client_service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
             option :quantize, default: {}, type: :hash
             option :distributed_tracing, default: false, type: :bool

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

@@ -31,7 +31,7 @@ module Datadog
             option :service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
             option :tag_body, default: false, type: :bool
           end

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

@@ -160,11 +160,11 @@ module Datadog
                  (?:"|%22)                                     # closing '"' at end of value
               )
              |(?: # other common secret values
-                 bearer(?:\s|%20)+[a-z0-9._\-]+
+                 bearer(?:\s|%20)+[a-z0-9._-]+
                 |token(?::|%3A)[a-z0-9]{13}
                 |gh[opsu]_[0-9a-zA-Z]{36}
                 |ey[I-L](?:[\w=-]|%3D)+\.ey[I-L](?:[\w=-]|%3D)+(?:\.(?:[\w.+/=-]|%3D|%2F|%2B)+)?
-                |-{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY-{5}[^\-]+-{5}END(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY(?:-{5})?(?:\n|%0A)?
+                |-{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY-{5}[^-]+-{5}END(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY(?:-{5})?(?:\n|%0A)?
                 |(?:ssh-(?:rsa|dss)|ecdsa-[a-z0-9]+-[a-z0-9]+)(?:\s|%20)*(?:[a-z0-9/.+]|%2F|%5C|%2B){100,}(?:=|%3D)*(?:(?:\s+)[a-z0-9._-]+)?
               )
             }ix.freeze

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

@@ -137,6 +137,12 @@ module Datadog
           private
 
           def instrumented_integrations
+            # `instrumented_integrations` method is added only if tracing contrib extensions are required.
+            # If tracing is used in manual mode without integrations enabled this method does not exist.
+            # CI visibility gem datadog-ci uses Datadog::Tracer without requiring datadog/tracing/contrib folder
+            # nor enabling any integrations by default which causes EnvironmentCollector to fail.
+            return {} unless Datadog.configuration.tracing.respond_to?(:instrumented_integrations)
+
             Datadog.configuration.tracing.instrumented_integrations
           end
 

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

@@ -18,6 +18,12 @@ module Datadog
         # @param propagation_styles [Hash<String,Object>]
         def initialize(propagation_styles:)
           @propagation_styles = propagation_styles
+          # We need to make sure propagation_style option is evaluated.
+          # Our options are lazy evaluated and it happens that propagation_style has the after_set callback
+          # that affect Datadog.configuration.tracing.distributed_tracing.propagation_inject_style and
+          # Datadog.configuration.tracing.distributed_tracing.propagation_extract_style
+          # By calling it here, we make sure if the customers has set any value either via code or ENV variable is applied.
+          ::Datadog.configuration.tracing.distributed_tracing.propagation_style
         end
 
         # inject! populates the env with span ID, trace ID and sampling priority
@@ -72,8 +78,10 @@ module Datadog
         #
         # @param data [Hash]
         def extract(data)
-          trace_digest = nil
-          dd_trace_digest = nil
+          return unless data
+          return if data.empty?
+
+          extracted_trace_digest = nil
 
           ::Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
             propagator = @propagation_styles[style]
@@ -83,42 +91,14 @@ module Datadog
               extracted_trace_digest = propagator.extract(data)
             rescue => e
               ::Datadog.logger.error(
-                'Error extracting distributed trace data. ' \
-              "Cause: #{e} Location: #{Array(e.backtrace).first}"
+                "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
               )
             end
 
-            # Skip if no valid data was found
-            next if extracted_trace_digest.nil?
-
-            # Keep track of the Datadog extracted digest, we want to return it if we have it.
-            if extracted_trace_digest && style == Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG
-              dd_trace_digest = extracted_trace_digest
-            end
-
-            # No previously extracted trace data, use the one we just extracted
-            if trace_digest.nil?
-              trace_digest = extracted_trace_digest
-            else
-              unless trace_digest.trace_id == extracted_trace_digest.trace_id \
-                    && trace_digest.span_id == extracted_trace_digest.span_id
-                # We have two mismatched propagation contexts
-                ::Datadog.logger.debug do
-                  'Cannot extract distributed trace data: extracted styles differ, ' \
-                  "#{trace_digest.trace_id} != #{extracted_trace_digest.trace_id} && " \
-                  "#{trace_digest.span_id} != #{extracted_trace_digest.span_id}"
-                end
-
-                # It's safer to create a new context than to attach ourselves to the wrong context
-                return TraceDigest.new # Early return from the whole method
-              end
-            end
+            break if extracted_trace_digest
           end
 
-          # Return the extracted trace digest if we found one or else a new empty digest.
-          # Always return the Datadog trace digest if one exists since it has more
-          # information than the B3 digest, e.g. origin, priority sampling values.
-          dd_trace_digest || trace_digest || nil
+          extracted_trace_digest
         end
       end
     end

data/lib/datadog/tracing/metadata/tagging.rb

@@ -59,8 +59,8 @@ module Datadog
         # A valid example is:
         #
         #   span.set_tags({ "http.method" => "GET", "user.id" => "234" })
-        def set_tags(tags)
-          tags.each { |k, v| set_tag(k, v) }
+        def set_tags(hash)
+          hash.each { |k, v| set_tag(k, v) }
         end
 
         # Returns true if the provided `tag` was set to a non-nil value.
@@ -111,7 +111,7 @@ module Datadog
         # Returns a copy of all metadata.
         # Keys for `@meta` and `@metrics` don't collide, by construction.
         def tags
-          @meta.merge(@metrics)
+          meta.merge(metrics)
         end
 
         protected

data/lib/datadog/tracing/sync_writer.rb

@@ -4,7 +4,7 @@ require_relative 'pipeline'
 require_relative 'runtime/metrics'
 require_relative 'writer'
 
-require_relative '../../ddtrace/transport/http'
+require_relative 'transport/http'
 
 module Datadog
   module Tracing
@@ -20,10 +20,10 @@ module Datadog
         :events,
         :transport
 
-      # @param [Datadog::Transport::Traces::Transport] transport a custom transport instance.
+      # @param [Datadog::Tracing::Transport::Traces::Transport] transport a custom transport instance.
       #   If provided, overrides `transport_options` and `agent_settings`.
       # @param [Hash<Symbol,Object>] transport_options options for the default transport instance.
-      # @param [Datadog::Core::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
+      # @param [Datadog::Tracing::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
       #   the default transport instance.
       def initialize(transport: nil, transport_options: {}, agent_settings: nil)
         @transport = transport || begin

data/lib/datadog/tracing/tracer.rb

@@ -353,6 +353,8 @@ module Datadog
         end
       end
 
+      # Creates a new TraceOperation, with events bounds to this Tracer instance.
+      # @return [TraceOperation]
       def start_trace(continue_from: nil)
         # Build a new trace using digest if provided.
         trace = build_trace(continue_from)

data/lib/datadog/{core → tracing}/transport/http/api/instance.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Datadog
-  module Core
+  module Tracing
     module Transport
       module HTTP
         module API

data/lib/datadog/{core → tracing}/transport/http/api/spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Datadog
-  module Core
+  module Tracing
     module Transport
       module HTTP
         module API

data/lib/datadog/tracing/transport/http/api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/encoding'
+
+require_relative '../../../core/transport/http/api/map'
+require_relative 'api/spec'
+
+require_relative 'traces'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Namespace for API components
+        module API
+          # Default API versions
+          V4 = 'v0.4'
+          V3 = 'v0.3'
+
+          module_function
+
+          def defaults
+            Datadog::Core::Transport::HTTP::API::Map[
+              V4 => Spec.new do |s|
+                s.traces = Traces::API::Endpoint.new(
+                  '/v0.4/traces',
+                  Core::Encoding::MsgpackEncoder,
+                  service_rates: true
+                )
+              end,
+              V3 => Spec.new do |s|
+                s.traces = Traces::API::Endpoint.new(
+                  '/v0.3/traces',
+                  Core::Encoding::MsgpackEncoder
+                )
+              end,
+            ].with_fallbacks(V4 => V3)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/{core → tracing}/transport/http/builder.rb

@@ -1,50 +1,18 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings_resolver'
-require_relative '../../../../ddtrace/transport/http/adapters/registry'
-require_relative '../../../../ddtrace/transport/http/api/map'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/instance'
+require_relative '../../../core/configuration/agent_settings_resolver'
+require_relative '../../../core/transport/http/adapters/registry'
+require_relative '../../../core/transport/http/api/map'
 require_relative 'api/instance'
-
-# TODO: Decouple transport/http/client
-#
-# The standard one does `include Transport::HTTP::Statistics` and performs
-# stats updates, which may or may not be desirable in general.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/client'
 require_relative 'client'
 
-# TODO: Decouple transport/http/builder
-#
-# This class is duplicated even though it is tantalisingly close to the
-# one in ddtrace/transport mostly because it refers to a different
-# `API::Instance` in `#api_instance_class` but also because it operates on a
-# different `HTTP::Client`, as well as de-hardcoding the transport class
-# `Transport::Traces::Transport` in `#to_transport`
-#
-# Additionally, its design makes it so there can be only one (API, Client,
-# Transport) triplet, requiring a new transport instance for any varying
-# element of the triplet.
-
 module Datadog
-  module Core
+  module Tracing
     module Transport
       module HTTP
         # Builds new instances of Transport::HTTP::Client
         class Builder
-          REGISTRY = Datadog::Transport::HTTP::Adapters::Registry.new
+          REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
 
           attr_reader \
             :apis,
@@ -59,7 +27,7 @@ module Datadog
             @default_headers = {}
 
             # Client settings
-            @apis = Datadog::Transport::HTTP::API::Map.new
+            @apis = Datadog::Core::Transport::HTTP::API::Map.new
             @default_api = nil
 
             # API settings
@@ -114,16 +82,17 @@ module Datadog
             @default_api = key
           end
 
-          def to_transport(klass)
+          def to_transport
             raise NoDefaultApiError if @default_api.nil?
 
-            klass.new(to_api_instances, @default_api)
+            # DEV: Should not be specific to traces
+            Transport::Traces::Transport.new(to_api_instances, @default_api)
           end
 
           def to_api_instances
             raise NoApisError if @apis.empty?
 
-            @apis.inject(Datadog::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
+            @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
               instances.tap do
                 api_options = @api_options[key].dup
 
@@ -154,46 +123,22 @@ module Datadog
 
           # Raised when the API key does not match known APIs.
           class UnknownApiError < StandardError
-            attr_reader :key
-
             def initialize(key)
-              super()
-
-              @key = key
-            end
-
-            def message
-              "Unknown transport API '#{key}'!"
+              super("Unknown transport API '#{key}'!")
             end
           end
 
           # Raised when the identifier cannot be matched to an adapter.
           class UnknownAdapterError < StandardError
-            attr_reader :type
-
             def initialize(type)
-              super()
-
-              @type = type
-            end
-
-            def message
-              "Unknown transport adapter '#{type}'!"
+              super("Unknown transport adapter '#{type}'!")
             end
           end
 
           # Raised when an adapter cannot be resolved for an API instance.
           class NoAdapterForApiError < StandardError
-            attr_reader :key
-
             def initialize(key)
-              super()
-
-              @key = key
-            end
-
-            def message
-              "No adapter resolved for transport API '#{key}'!"
+              super("No adapter resolved for transport API '#{key}'!")
             end
           end