datadog 2.10.0 → 2.12.0

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -47,14 +47,26 @@ module Datadog
           end
 
           def execute_query(*args, query:, **kwargs)
-            trace(proc { super }, 'execute', query.selected_operation_name, query: query) do |span|
-              span.set_tag('graphql.source', query.query_string)
-              span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
-              span.set_tag('graphql.operation.name', query.selected_operation_name) if query.selected_operation_name
-              query.variables.instance_variable_get(:@storage).each do |key, value|
-                span.set_tag("graphql.variables.#{key}", value)
-              end
-            end
+            trace(
+              proc { super },
+              'execute',
+              query.selected_operation_name,
+              lambda { |span|
+                span.set_tag('graphql.source', query.query_string)
+                span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
+                if query.selected_operation_name
+                  span.set_tag(
+                    'graphql.operation.name',
+                    query.selected_operation_name
+                  )
+                end
+                query.variables.instance_variable_get(:@storage).each do |key, value|
+                  span.set_tag("graphql.variables.#{key}", value)
+                end
+              },
+              ->(span) { add_query_error_events(span, query.context.errors) },
+              query: query,
+            )
           end
 
           def execute_query_lazy(*args, query:, multiplex:, **kwargs)
@@ -131,7 +143,16 @@ module Datadog
 
           private
 
-          def trace(callable, trace_key, resource, **kwargs)
+          # Traces the given callable with the given trace key, resource, and kwargs.
+          #
+          # @param callable [Proc] the original method call
+          # @param trace_key [String] the sub-operation name (`"graphql.#{trace_key}"`)
+          # @param resource [String] the resource name for the trace
+          # @param before [Proc, nil] a callable to run before the trace, same as the block parameter
+          # @param after [Proc, nil] a callable to run after the trace, which has access to query values after execution
+          # @param kwargs [Hash] the arguments to pass to `prepare_span`
+          # @yield [Span] the block to run before the trace, same as the `before` parameter
+          def trace(callable, trace_key, resource, before = nil, after = nil, **kwargs, &before_block)
             config = Datadog.configuration.tracing[:graphql]
 
             Tracing.trace(
@@ -144,11 +165,20 @@ module Datadog
                 Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
               end
 
-              yield(span) if block_given?
+              # A sanity check for us.
+              raise 'Please provide either `before` or a block, but not both' if before && before_block
+
+              if (before_callable = before || before_block)
+                before_callable.call(span)
+              end
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span
 
-              callable.call
+              ret = callable.call
+
+              after.call(span) if after
+
+              ret
             end
           end
 
@@ -163,6 +193,67 @@ module Datadog
               operations
             end
           end
+
+          # Create a Span Event for each error that occurs at query level.
+          #
+          # These are represented in the Datadog App as special GraphQL errors,
+          # given their event name `dd.graphql.query.error`.
+          def add_query_error_events(span, errors)
+            capture_extensions = Datadog.configuration.tracing[:graphql][:error_extensions]
+            errors.each do |error|
+              extensions = if !capture_extensions.empty? && (extensions = error.extensions)
+                             # Capture extensions, ensuring all values are primitives
+                             extensions.each_with_object({}) do |(key, value), hash|
+                               next unless capture_extensions.include?(key.to_s)
+
+                               value = case value
+                                       when TrueClass, FalseClass, Integer, Float
+                                         value
+                                       else
+                                         # Stringify anything that is not a boolean or a number
+                                         value.to_s
+                                       end
+
+                               hash["extensions.#{key}"] = value
+                             end
+                           else
+                             {}
+                           end
+
+              # {::GraphQL::Error#to_h} returns the error formatted in compliance with the GraphQL spec.
+              # This is an unwritten contract in the `graphql` library.
+              # See for an example: https://github.com/rmosolgo/graphql-ruby/blob/0afa241775e5a113863766cce126214dee093464/lib/graphql/execution_error.rb#L32
+              graphql_error = error.to_h
+              error = Core::Error.build_from(error)
+
+              span.span_events << Datadog::Tracing::SpanEvent.new(
+                Ext::EVENT_QUERY_ERROR,
+                attributes: extensions.merge!(
+                  message: graphql_error['message'],
+                  type: error.type,
+                  stacktrace: error.backtrace,
+                  locations: serialize_error_locations(graphql_error['locations']),
+                  path: graphql_error['path'],
+                )
+              )
+            end
+          end
+
+          # Serialize error's `locations` array as an array of Strings, given
+          # Span Events do not support hashes nested inside arrays.
+          #
+          # Here's an example in which `locations`:
+          #   [
+          #    {"line" => 3, "column" => 10},
+          #    {"line" => 7, "column" => 8},
+          #   ]
+          # is serialized as:
+          #   ["3:10", "7:8"]
+          def serialize_error_locations(locations)
+            locations.map do |location|
+              "#{location['line']}:#{location['column']}"
+            end
+          end
         end
       end
     end

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/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/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/sync_writer.rb

@@ -17,6 +17,7 @@ module Datadog
     # @public_api
     class SyncWriter
       attr_reader \
+        :logger,
         :events,
         :transport
 
@@ -25,7 +26,9 @@ module Datadog
       # @param [Hash<Symbol,Object>] transport_options options for the default transport instance.
       # @param [Datadog::Tracing::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
       #   the default transport instance.
-      def initialize(transport: nil, transport_options: {}, agent_settings: nil)
+      def initialize(transport: nil, transport_options: {}, agent_settings: nil, logger: Datadog.logger)
+        @logger = logger
+
         @transport = transport || begin
           transport_options[:agent_settings] = agent_settings if agent_settings
           Transport::HTTP.default(**transport_options)
@@ -40,7 +43,7 @@ module Datadog
       def write(trace)
         flush_trace(trace)
       rescue => e
-        Datadog.logger.debug(e)
+        logger.debug(e)
       end
 
       # Does nothing.

data/lib/datadog/tracing/tracer.rb

@@ -28,7 +28,8 @@ module Datadog
         :provider,
         :sampler,
         :span_sampler,
-        :tags
+        :tags,
+        :logger
 
       attr_accessor \
         :default_service,
@@ -52,17 +53,19 @@ module Datadog
         context_provider: DefaultContextProvider.new,
         default_service: Core::Environment::Ext::FALLBACK_SERVICE_NAME,
         enabled: true,
+        logger: Datadog.logger,
         sampler: Sampling::PrioritySampler.new(
           base_sampler: Sampling::AllSampler.new,
           post_sampler: Sampling::RuleSampler.new
         ),
         span_sampler: Sampling::Span::Sampler.new,
         tags: {},
-        writer: Writer.new
+        writer: Writer.new(logger: logger)
       )
         @trace_flush = trace_flush
         @default_service = default_service
         @enabled = enabled
+        @logger = logger
         @provider = context_provider
         @sampler = sampler
         @span_sampler = span_sampler
@@ -146,7 +149,7 @@ module Datadog
                     active_trace
                   end
         rescue StandardError => e
-          Datadog.logger.debug { "Failed to trace: #{e}" }
+          logger.debug { "Failed to trace: #{e}" }
 
           # Tracing failed: fallback and run code without tracing.
           return skip_trace(name, &block)
@@ -268,7 +271,7 @@ module Datadog
           @sampler.sample!(trace_op)
         rescue StandardError => e
           SAMPLE_TRACE_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -488,7 +491,7 @@ module Datadog
           @span_sampler.sample!(trace_op, span)
         rescue StandardError => e
           SAMPLE_SPAN_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -504,7 +507,7 @@ module Datadog
           write(trace) if trace && !trace.empty?
         rescue StandardError => e
           FLUSH_TRACE_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -518,7 +521,7 @@ module Datadog
         return unless trace && @writer
 
         if Datadog.configuration.diagnostics.debug
-          Datadog.logger.debug { "Writing #{trace.length} spans (enabled: #{@enabled})\n#{trace.spans.pretty_inspect}" }
+          logger.debug { "Writing #{trace.length} spans (enabled: #{@enabled})\n#{trace.spans.pretty_inspect}" }
         end
 
         @writer.write(trace)

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

@@ -3,7 +3,8 @@
 require_relative '../../../core/encoding'
 
 require_relative '../../../core/transport/http/api/map'
-require_relative 'api/spec'
+require_relative '../../../core/transport/http/api/instance'
+require_relative '../../../core/transport/http/api/spec'
 
 require_relative 'traces'
 
@@ -20,7 +21,7 @@ module Datadog
           module_function
 
           def defaults
-            Datadog::Core::Transport::HTTP::API::Map[
+            Core::Transport::HTTP::API::Map[
               V4 => Spec.new do |s|
                 s.traces = Traces::API::Endpoint.new(
                   '/v0.4/traces',
@@ -36,6 +37,14 @@ module Datadog
               end,
             ].with_fallbacks(V4 => V3)
           end
+
+          class Instance < Core::Transport::HTTP::API::Instance
+            include Traces::API::Instance
+          end
+
+          class Spec < Core::Transport::HTTP::API::Spec
+            include Traces::API::Spec
+          end
         end
       end
     end

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

@@ -6,7 +6,6 @@ require_relative '../traces'
 require_relative 'client'
 require_relative '../../../core/transport/http/response'
 require_relative '../../../core/transport/http/api/endpoint'
-require_relative 'api/instance'
 
 module Datadog
   module Tracing
@@ -143,8 +142,6 @@ module Datadog
 
           # Add traces behavior to transport components
           HTTP::Client.include(Traces::Client)
-          HTTP::API::Spec.include(Traces::API::Spec)
-          HTTP::API::Instance.include(Traces::API::Instance)
         end
       end
     end

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

@@ -8,8 +8,8 @@ require_relative '../../core/transport/ext'
 require_relative '../../core/transport/http/adapters/net'
 require_relative '../../core/transport/http/adapters/test'
 require_relative '../../core/transport/http/adapters/unix_socket'
+require_relative '../../core/transport/http/builder'
 require_relative 'http/api'
-require_relative 'http/builder'
 require_relative '../../../datadog/version'
 
 module Datadog
@@ -30,8 +30,10 @@ module Datadog
         module_function
 
         # Builds a new Transport::HTTP::Client
-        def new(&block)
-          Builder.new(&block).to_transport
+        def new(klass, &block)
+          Core::Transport::HTTP::Builder.new(
+            api_instance_class: API::Instance, &block
+          ).to_transport(klass)
         end
 
         # Builds a new Transport::HTTP::Client with default settings
@@ -40,7 +42,7 @@ module Datadog
           agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
           **options
         )
-          new do |transport|
+          new(Transport::Traces::Transport) do |transport|
             transport.adapter(agent_settings)
             transport.headers default_headers
 
@@ -86,12 +88,15 @@ module Datadog
         end
 
         # Add adapters to registry
-        Builder::REGISTRY.set(
+        Core::Transport::HTTP::Builder::REGISTRY.set(
           Datadog::Core::Transport::HTTP::Adapters::Net,
           Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
         )
-        Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
-        Builder::REGISTRY.set(
+        Core::Transport::HTTP::Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::Test,
+          Datadog::Core::Transport::Ext::Test::ADAPTER
+        )
+        Core::Transport::HTTP::Builder::REGISTRY.set(
           Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
           Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
         )

data/lib/datadog/tracing/transport/serializable_trace.rb

@@ -14,7 +14,7 @@ module Datadog
 
         # @param trace [Datadog::Trace] the trace to serialize
         # @param native_events_supported [Boolean] whether the agent supports span events as a top-level field
-        def initialize(trace, native_events_supported = false)
+        def initialize(trace, native_events_supported:)
           @trace = trace
           @native_events_supported = native_events_supported
         end
@@ -29,13 +29,17 @@ module Datadog
         # @param packer [MessagePack::Packer] serialization buffer, can be +nil+ with JRuby
         def to_msgpack(packer = nil)
           # As of 1.3.3, JRuby implementation doesn't pass an existing packer
-          trace.spans.map { |s| SerializableSpan.new(s, @native_events_supported) }.to_msgpack(packer)
+          trace.spans.map do |s|
+            SerializableSpan.new(s, native_events_supported: @native_events_supported)
+          end.to_msgpack(packer)
         end
 
         # JSON serializer interface.
         # Used by older version of the transport.
         def to_json(*args)
-          trace.spans.map { |s| SerializableSpan.new(s, @native_events_supported).to_hash }.to_json(*args)
+          trace.spans.map do |s|
+            SerializableSpan.new(s, native_events_supported: @native_events_supported).to_hash
+          end.to_json(*args)
         end
       end
 
@@ -46,7 +50,7 @@ module Datadog
 
         # @param span [Datadog::Span] the span to serialize
         # @param native_events_supported [Boolean] whether the agent supports span events as a top-level field
-        def initialize(span, native_events_supported)
+        def initialize(span, native_events_supported:)
           @span = span
           @trace_id = Tracing::Utils::TraceId.to_low_order(span.trace_id)
           @native_events_supported = native_events_supported

data/lib/datadog/tracing/transport/traces.rb

@@ -50,8 +50,9 @@ module Datadog
           #
           # @param encoder [Datadog::Core::Encoding::Encoder]
           # @param max_size [String] maximum acceptable payload size
-          def initialize(encoder, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
+          def initialize(encoder, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
             @encoder = encoder
+            @native_events_supported = native_events_supported
             @max_size = max_size
           end
 
@@ -77,7 +78,7 @@ module Datadog
           private
 
           def encode_one(trace)
-            encoded = Encoder.encode_trace(encoder, trace)
+            encoded = Encoder.encode_trace(encoder, trace, native_events_supported: @native_events_supported)
 
             if encoded.size > max_size
               # This single trace is too large, we can't flush it
@@ -95,17 +96,18 @@ module Datadog
         module Encoder
           module_function
 
-          def encode_trace(encoder, trace)
+          def encode_trace(encoder, trace, native_events_supported:)
             # Format the trace for transport
             TraceFormatter.format!(trace)
 
             # Make the trace serializable
-            serializable_trace = SerializableTrace.new(trace)
-
-            Datadog.logger.debug { "Flushing trace: #{JSON.dump(serializable_trace)}" }
+            serializable_trace = SerializableTrace.new(trace, native_events_supported: native_events_supported)
 
             # Encode the trace
-            encoder.encode(serializable_trace)
+            encoder.encode(serializable_trace).tap do |encoded|
+              # Print the actual serialized trace, since the encoder can change make non-trivial changes
+              Datadog.logger.debug { "Flushing trace: #{encoder.decode(encoded)}" }
+            end
           end
         end
 
@@ -126,7 +128,10 @@ module Datadog
 
           def send_traces(traces)
             encoder = current_api.encoder
-            chunker = Datadog::Tracing::Transport::Traces::Chunker.new(encoder)
+            chunker = Datadog::Tracing::Transport::Traces::Chunker.new(
+              encoder,
+              native_events_supported: native_events_supported?
+            )
 
             responses = chunker.encode_in_chunks(traces.lazy).map do |encoded_traces, trace_count|
               request = Request.new(EncodedParcel.new(encoded_traces, trace_count))
@@ -188,6 +193,18 @@ module Datadog
             @client = HTTP::Client.new(current_api)
           end
 
+          # Queries the agent for native span events serialization support.
+          # This changes how the serialization of span events performed.
+          def native_events_supported?
+            return @native_events_supported if defined?(@native_events_supported)
+
+            if (res = Datadog.send(:components).agent_info.fetch)
+              @native_events_supported = res.span_events == true
+            else
+              false
+            end
+          end
+
           # Raised when configured with an unknown API version
           class UnknownApiVersionError < StandardError
             attr_reader :version

data/lib/datadog/tracing/workers/trace_writer.rb

@@ -17,10 +17,13 @@ module Datadog
       # Writes traces to transport synchronously
       class TraceWriter < Core::Worker
         attr_reader \
+          :logger,
           :transport
 
         # rubocop:disable Lint/MissingSuper
         def initialize(options = {})
+          @logger = options[:logger] || Datadog.logger
+
           transport_options = options.fetch(:transport_options, {})
 
           transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
@@ -43,7 +46,7 @@ module Datadog
           traces = process_traces(traces)
           flush_traces(traces)
         rescue StandardError => e
-          Datadog.logger.warn(
+          logger.warn(
             "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
           )
         end

data/lib/datadog/tracing/workers.rb

@@ -18,8 +18,7 @@ module Datadog
         BACK_OFF_MAX = 5
         DEFAULT_SHUTDOWN_TIMEOUT = 1
 
-        attr_reader \
-          :trace_buffer
+        attr_reader :trace_buffer, :logger
 
         def initialize(options = {})
           @transport = options[:transport]
@@ -42,6 +41,8 @@ module Datadog
           @mutex = Mutex.new
           @worker = nil
           @run = false
+
+          @logger = options.fetch(:logger)
         end
 
         # Callback function that process traces and executes the +send_traces()+ method.
@@ -56,7 +57,7 @@ module Datadog
             # ensures that the thread will not die because of an exception.
             # TODO[manu]: findout the reason and reschedule the send if it's not
             # a fatal exception
-            Datadog.logger.warn(
+            logger.warn(
               "Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )
           end
@@ -68,7 +69,7 @@ module Datadog
             return if @run
 
             @run = true
-            Datadog.logger.debug { "Starting thread for: #{self}" }
+            logger.debug { "Starting thread for: #{self}" }
             @worker = Thread.new { perform }
             @worker.name = self.class.name
             @worker.thread_variable_set(:fork_safe, true)

data/lib/datadog/tracing/writer.rb

@@ -13,11 +13,14 @@ module Datadog
     # @public_api
     class Writer
       attr_reader \
+        :logger,
         :transport,
         :worker,
         :events
 
       def initialize(options = {})
+        @logger = options[:logger] || Datadog.logger
+
         # writer and transport parameters
         @buff_size = options.fetch(:buffer_size, Workers::AsyncTransport::DEFAULT_BUFFER_MAX_SIZE)
         @flush_interval = options.fetch(:flush_interval, Workers::AsyncTransport::DEFAULT_FLUSH_INTERVAL)
@@ -119,7 +122,7 @@ module Datadog
         if worker_local
           worker_local.enqueue_trace(trace)
         elsif !@stopped
-          Datadog.logger.debug('Writer either failed to start or was stopped before #write could complete')
+          logger.debug('Writer either failed to start or was stopped before #write could complete')
         end
       end
 
@@ -160,7 +163,8 @@ module Datadog
           buffer_size: @buff_size,
           on_trace: @trace_handler,
           interval: @flush_interval,
-          shutdown_timeout: @shutdown_timeout
+          shutdown_timeout: @shutdown_timeout,
+          logger: logger,
         )
 
         @worker.start

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 10
+    MINOR = 12
     PATCH = 0
     PRE = nil
     BUILD = nil