datadog 2.12.0 → 2.22.0

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

@@ -43,15 +43,17 @@ module Datadog
           # We set the value to a conservative 5 MiB, in case network speed is slow.
           DEFAULT_MAX_PAYLOAD_SIZE = 5 * 1024 * 1024
 
-          attr_reader :encoder, :max_size
+          attr_reader :encoder, :max_size, :logger
 
           #
           # Single traces larger than +max_size+ will be discarded.
           #
           # @param encoder [Datadog::Core::Encoding::Encoder]
+          # @param logger [Datadog::Core::Logger]
           # @param max_size [String] maximum acceptable payload size
-          def initialize(encoder, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
+          def initialize(encoder, logger:, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
             @encoder = encoder
+            @logger = logger
             @native_events_supported = native_events_supported
             @max_size = max_size
           end
@@ -64,11 +66,11 @@ module Datadog
           #   number of traces
           def encode_in_chunks(traces)
             encoded_traces = if traces.respond_to?(:filter_map)
-                               # DEV Supported since Ruby 2.7, saves an intermediate object creation
-                               traces.filter_map { |t| encode_one(t) }
-                             else
-                               traces.map { |t| encode_one(t) }.reject(&:nil?)
-                             end
+              # DEV Supported since Ruby 2.7, saves an intermediate object creation
+              traces.filter_map { |t| encode_one(t) }
+            else
+              traces.map { |t| encode_one(t) }.reject(&:nil?)
+            end
 
             Datadog::Core::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|
               [encoder.join(chunk), chunk.size]
@@ -78,11 +80,16 @@ module Datadog
           private
 
           def encode_one(trace)
-            encoded = Encoder.encode_trace(encoder, trace, native_events_supported: @native_events_supported)
+            encoded = Encoder.encode_trace(
+              encoder,
+              trace,
+              logger: logger,
+              native_events_supported: @native_events_supported
+            )
 
             if encoded.size > max_size
               # This single trace is too large, we can't flush it
-              Datadog.logger.debug { "Dropping trace. Payload too large: '#{trace.inspect}'" }
+              logger.debug { "Dropping trace. Payload too large: '#{trace.inspect}'" }
               Datadog.health_metrics.transport_trace_too_large(1)
 
               return nil
@@ -96,7 +103,7 @@ module Datadog
         module Encoder
           module_function
 
-          def encode_trace(encoder, trace, native_events_supported:)
+          def encode_trace(encoder, trace, logger:, native_events_supported:)
             # Format the trace for transport
             TraceFormatter.format!(trace)
 
@@ -106,7 +113,7 @@ module Datadog
             # Encode the 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)}" }
+              logger.debug { "Flushing trace: #{encoder.decode(encoded)}" }
             end
           end
         end
@@ -117,11 +124,12 @@ module Datadog
         # batches of traces into smaller chunks and handles
         # API version downgrade handshake.
         class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-          def initialize(apis, default_api)
+          def initialize(apis, default_api, logger: Datadog.logger)
             @apis = apis
             @default_api = default_api
+            @logger = logger
 
             change_api!(default_api)
           end
@@ -130,6 +138,7 @@ module Datadog
             encoder = current_api.encoder
             chunker = Datadog::Tracing::Transport::Traces::Chunker.new(
               encoder,
+              logger: logger,
               native_events_supported: native_events_supported?
             )
 
@@ -190,7 +199,7 @@ module Datadog
             raise UnknownApiVersionError, api_id unless apis.key?(api_id)
 
             @current_api_id = api_id
-            @client = HTTP::Client.new(current_api)
+            @client = HTTP::Client.new(current_api, logger: logger)
           end
 
           # Queries the agent for native span events serialization support.
@@ -198,6 +207,14 @@ module Datadog
           def native_events_supported?
             return @native_events_supported if defined?(@native_events_supported)
 
+            # Check for an explicit override
+            option = Datadog.configuration.tracing.native_span_events
+            unless option.nil?
+              @native_events_supported = option
+              return option
+            end
+
+            # Otherwise, check for agent support, to ensure a configuration-less setup.
             if (res = Datadog.send(:components).agent_info.fetch)
               @native_events_supported = res.span_events == true
             else

data/lib/datadog/tracing/utils.rb

@@ -24,7 +24,7 @@ module Datadog
 
       # While we only generate 63-bit integers due to limitations in other languages, we support
       # parsing 64-bit integers for distributed tracing since an upstream system may generate one
-      EXTERNAL_MAX_ID = 1 << 64
+      EXTERNAL_MAX_ID = (1 << 64) - 1
 
       # We use a custom random number generator because we want no interference
       # with the default one. Using the default prng, we could break code that

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

@@ -18,18 +18,18 @@ module Datadog
       class TraceWriter < Core::Worker
         attr_reader \
           :logger,
-          :transport
+          :transport,
+          :agent_settings
 
         # 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)
+          @agent_settings = options[:agent_settings]
 
           @transport = options.fetch(:transport) do
-            Datadog::Tracing::Transport::HTTP.default(**transport_options)
+            Datadog::Tracing::Transport::HTTP.default(agent_settings: agent_settings, logger: logger, **transport_options)
           end
         end
         # rubocop:enable Lint/MissingSuper
@@ -45,7 +45,7 @@ module Datadog
         def write_traces(traces)
           traces = process_traces(traces)
           flush_traces(traces)
-        rescue StandardError => e
+        rescue => e
           logger.warn(
             "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
           )
@@ -119,7 +119,7 @@ module Datadog
         # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#perform is spec'd to return the
         # result from the writer, whereas this method always returns nil.
         def perform(traces)
-          super(traces).tap do |responses|
+          super.tap do |responses|
             loop_back_off! if responses.find(&:server_error?)
           end
 
@@ -152,16 +152,16 @@ module Datadog
 
         def fork_policy=(policy)
           # Translate to Workers::Async::Thread policy
-          thread_fork_policy =  case policy
-                                when Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                  policy
-                                when FORK_POLICY_SYNC
-                                  # Stop the async thread because the writer
-                                  # will bypass and run synchronously.
-                                  Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                else
-                                  Core::Workers::Async::Thread::FORK_POLICY_RESTART
-                                end
+          thread_fork_policy = case policy
+          when Core::Workers::Async::Thread::FORK_POLICY_STOP
+            policy
+          when FORK_POLICY_SYNC
+            # Stop the async thread because the writer
+            # will bypass and run synchronously.
+            Core::Workers::Async::Thread::FORK_POLICY_STOP
+          else
+            Core::Workers::Async::Thread::FORK_POLICY_RESTART
+          end
 
           # Update thread fork policy
           super(thread_fork_policy)

data/lib/datadog/tracing/workers.rb

@@ -53,7 +53,7 @@ module Datadog
             traces = @trace_buffer.pop
             traces = Pipeline.process!(traces)
             @trace_task.call(traces, @transport) unless @trace_task.nil? || traces.empty?
-          rescue StandardError => e
+          rescue => e
             # 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
@@ -107,7 +107,7 @@ module Datadog
 
         private
 
-        alias flush_data callback_traces
+        alias_method :flush_data, :callback_traces
 
         def perform
           loop do

data/lib/datadog/tracing/writer.rb

@@ -16,7 +16,8 @@ module Datadog
         :logger,
         :transport,
         :worker,
-        :events
+        :events,
+        :agent_settings
 
       def initialize(options = {})
         @logger = options[:logger] || Datadog.logger
@@ -25,12 +26,11 @@ module Datadog
         @buff_size = options.fetch(:buffer_size, Workers::AsyncTransport::DEFAULT_BUFFER_MAX_SIZE)
         @flush_interval = options.fetch(:flush_interval, Workers::AsyncTransport::DEFAULT_FLUSH_INTERVAL)
         transport_options = options.fetch(:transport_options, {})
-
-        transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
+        @agent_settings = options[:agent_settings]
 
         # transport and buffers
         @transport = options.fetch(:transport) do
-          Transport::HTTP.default(**transport_options)
+          Transport::HTTP.default(agent_settings: agent_settings, logger: logger, **transport_options)
         end
 
         @shutdown_timeout = options.fetch(:shutdown_timeout, Workers::AsyncTransport::DEFAULT_SHUTDOWN_TIMEOUT)

data/lib/datadog/tracing.rb

@@ -26,7 +26,6 @@ module Datadog
         id: nil,
         &block
       )
-
         tracer.trace(
           name,
           continue_from: continue_from,
@@ -82,7 +81,7 @@ module Datadog
       # @public_api
       def keep!
         trace = active_trace
-        active_trace.keep! if trace
+        trace&.keep!
       end
 
       # (see Datadog::Tracing::TraceSegment#reject!)
@@ -90,7 +89,7 @@ module Datadog
       # @public_api
       def reject!
         trace = active_trace
-        active_trace.reject! if trace
+        trace&.reject!
       end
 
       # (see Datadog::Tracing::Tracer#active_correlation)
@@ -127,6 +126,20 @@ module Datadog
         correlation.to_log_format
       end
 
+      # Returns the baggage for the current trace.
+      #
+      # If there is no active trace, a new one is created.
+      #
+      # @return [Datadog::Tracing::Distributed::Baggage] The baggage for the current trace.
+      # @public_api
+      def baggage
+        # Baggage should not be dependent on there being an active trace.
+        # So we create a new TraceOperation if there isn't one.
+        active_trace = self.active_trace || tracer.continue_trace!(nil)
+        active_trace.baggage ||= {}
+        active_trace.baggage
+      end
+
       # Gracefully shuts down the tracer.
       #
       # The public tracing API will still respond to method calls as usual

data/lib/datadog/version.rb

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

data/lib/datadog.rb

@@ -7,7 +7,13 @@ require_relative 'datadog/tracing/contrib'
 # Load other products (must follow tracing)
 require_relative 'datadog/profiling'
 require_relative 'datadog/appsec'
+require_relative 'datadog/di'
+
 # Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
-# trace point. Only load DI on supported Ruby versions.
-require_relative 'datadog/di' if RUBY_VERSION >= '2.6'
+# trace point. Activate DI automatically on supported Ruby versions but
+# always load its settings so that, for example, turning DI off when
+# we are on Ruby 2.5 does not produce exceptions.
+require_relative 'datadog/di/boot' if RUBY_VERSION >= '2.6' && RUBY_ENGINE != 'jruby'
+
+require_relative 'datadog/error_tracking'
 require_relative 'datadog/kit'