ddtrace 0.52.0 → 0.54.2

data/lib/ddtrace/profiling/pprof/stack_sample.rb

@@ -30,8 +30,9 @@ module Datadog
         def initialize(*_)
           super
 
+          @most_recent_trace_samples = {}
           @processed_unique_stacks = 0
-          @processed_with_trace_ids = 0
+          @processed_with_trace = 0
         end
 
         def add_events!(stack_samples)
@@ -40,9 +41,28 @@ module Datadog
         end
 
         def stack_sample_group_key(stack_sample)
+          # We want to make sure we have the most recent sample for any trace.
+          # (This is done here to save an iteration over all samples.)
+          update_most_recent_trace_sample(stack_sample)
+
           stack_sample.hash
         end
 
+        # Track the most recent sample for each trace (identified by root span id)
+        def update_most_recent_trace_sample(stack_sample)
+          return unless stack_sample.root_span_id && stack_sample.trace_resource
+
+          # Update trace resource with most recent value
+          if (most_recent_trace_sample = @most_recent_trace_samples[stack_sample.root_span_id])
+            if most_recent_trace_sample.timestamp < stack_sample.timestamp
+              @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
+            end
+          else
+            # Add trace resource
+            @most_recent_trace_samples[stack_sample.root_span_id] = stack_sample
+          end
+        end
+
         def build_samples(stack_samples)
           groups = group_events(stack_samples, &method(:stack_sample_group_key))
           groups.collect do |_group_key, group|
@@ -64,7 +84,7 @@ module Datadog
           )
         end
 
-        def build_sample_values(stack_sample)
+        def build_event_values(stack_sample)
           no_value = Datadog::Ext::Profiling::Pprof::SAMPLE_VALUE_NO_VALUE
           values = super(stack_sample)
           values[sample_value_index(:cpu_time_ns)] = stack_sample.cpu_time_interval_ns || no_value
@@ -80,15 +100,15 @@ module Datadog
             )
           ]
 
-          trace_id = stack_sample.trace_id || 0
+          root_span_id = stack_sample.root_span_id || 0
           span_id = stack_sample.span_id || 0
 
-          if trace_id != 0 && span_id != 0
-            @processed_with_trace_ids += 1
+          if root_span_id != 0 && span_id != 0
+            @processed_with_trace += 1
 
             labels << Perftools::Profiles::Label.new(
-              key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ID),
-              str: builder.string_table.fetch(trace_id.to_s)
+              key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_LOCAL_ROOT_SPAN_ID),
+              str: builder.string_table.fetch(root_span_id.to_s)
             )
 
             labels << Perftools::Profiles::Label.new(
@@ -96,7 +116,10 @@ module Datadog
               str: builder.string_table.fetch(span_id.to_s)
             )
 
-            trace_resource = stack_sample.trace_resource_container && stack_sample.trace_resource_container.latest
+            # Use most up-to-date trace resource, if available.
+            # Otherwise, use the trace resource provided.
+            trace_resource = @most_recent_trace_samples.fetch(stack_sample.root_span_id, stack_sample).trace_resource
+
             if trace_resource && !trace_resource.empty?
               labels << Perftools::Profiles::Label.new(
                 key: builder.string_table.fetch(Datadog::Ext::Profiling::Pprof::LABEL_KEY_TRACE_ENDPOINT),
@@ -109,7 +132,7 @@ module Datadog
         end
 
         def debug_statistics
-          "unique stacks: #{@processed_unique_stacks}, of which had active traces: #{@processed_with_trace_ids}"
+          "unique stacks: #{@processed_unique_stacks}, of which had active traces: #{@processed_with_trace}"
         end
       end
     end

data/lib/ddtrace/profiling/pprof/template.rb

@@ -80,8 +80,8 @@ module Datadog
           converters.values.map(&:debug_statistics).join(', ')
         end
 
-        def to_pprof
-          profile = builder.build_profile
+        def to_pprof(start:, finish:)
+          profile = builder.build_profile(start: start, finish: finish)
           data = builder.encode_profile(profile)
           types = sample_type_mappings.keys
 

data/lib/ddtrace/profiling/scheduler.rb

@@ -17,6 +17,10 @@ module Datadog
       # Profiles with duration less than this will not be reported
       PROFILE_DURATION_THRESHOLD_SECONDS = 1
 
+      # We sleep for at most this duration seconds before reporting data to avoid multi-process applications all
+      # reporting profiles at the exact same time
+      DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS = 3
+
       private_constant :DEFAULT_INTERVAL_SECONDS, :MINIMUM_INTERVAL_SECONDS, :PROFILE_DURATION_THRESHOLD_SECONDS
 
       attr_reader \
@@ -62,10 +66,6 @@ module Datadog
         end
       end
 
-      def loop_back_off?
-        false
-      end
-
       def after_fork
         # Clear recorder's buffers by flushing events.
         # Objects from parent process will copy-on-write,
@@ -110,6 +110,22 @@ module Datadog
           return flush
         end
 
+        # Sleep for a bit to cause misalignment between profilers in multi-process applications
+        #
+        # When not being run in a loop, it means the scheduler has not been started or was stopped, and thus
+        # a) it's being shutting down (and is trying to report the last profile)
+        # b) it's being run as a one-shot, usually in a test
+        # ...so in those cases we don't sleep
+        #
+        # During PR review (https://github.com/DataDog/dd-trace-rb/pull/1807) we discussed the possible alternative of
+        # just sleeping before starting the scheduler loop. We ended up not going with that option to avoid the first
+        # profile containing up to DEFAULT_INTERVAL_SECONDS + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual DEFAULT_INTERVAL_SECONDS size.
+        if run_loop?
+          jitter_seconds = rand * DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS # floating point number between (0.0...maximum)
+          sleep(jitter_seconds)
+        end
+
         # Send events to each exporter
         if flush.event_count > 0
           exporters.each do |exporter|

data/lib/ddtrace/profiling/tasks/setup.rb

@@ -1,22 +1,20 @@
 # typed: false
-require 'ddtrace'
 require 'ddtrace/utils/only_once'
 require 'ddtrace/profiling'
-require 'ddtrace/profiling/ext/cpu'
 require 'ddtrace/profiling/ext/forking'
 
 module Datadog
   module Profiling
     module Tasks
-      # Takes care of loading our extensions/monkey patches to handle fork() and CPU profiling.
+      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
       class Setup
         ACTIVATE_EXTENSIONS_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
 
         def run
           ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
             begin
+              check_if_cpu_time_profiling_is_supported
               activate_forking_extensions
-              activate_cpu_extensions
               setup_at_fork_hooks
             rescue StandardError, ScriptError => e
               Datadog.logger.warn do
@@ -40,19 +38,15 @@ module Datadog
           end
         end
 
-        def activate_cpu_extensions
-          if Ext::CPU.supported?
-            Ext::CPU.apply!
-          elsif Datadog.configuration.profiling.enabled
+        def check_if_cpu_time_profiling_is_supported
+          unsupported = cpu_time_profiling_unsupported_reason
+
+          if unsupported
             Datadog.logger.info do
               'CPU time profiling skipped because native CPU time is not supported: ' \
-              "#{Ext::CPU.unsupported_reason}. Profiles containing Wall time will still be reported."
+              "#{unsupported}. Profiles containing 'Wall time' data will still be reported."
             end
           end
-        rescue StandardError, ScriptError => e
-          Datadog.logger.warn do
-            "Profiler CPU profiling extensions unavailable. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
-          end
         end
 
         def setup_at_fork_hooks
@@ -76,6 +70,20 @@ module Datadog
             end
           end
         end
+
+        def cpu_time_profiling_unsupported_reason
+          # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons
+
+          if RUBY_ENGINE == 'jruby'
+            'JRuby is not supported'
+          elsif RUBY_PLATFORM.include?('darwin')
+            'Feature requires Linux; macOS is not supported'
+          elsif RUBY_PLATFORM =~ /(mswin|mingw)/
+            'Feature requires Linux; Windows is not supported'
+          elsif !RUBY_PLATFORM.include?('linux')
+            "Feature requires Linux; #{RUBY_PLATFORM} is not supported"
+          end
+        end
       end
     end
   end

data/lib/ddtrace/profiling/trace_identifiers/ddtrace.rb

@@ -6,10 +6,10 @@ require 'ddtrace/ext/http'
 module Datadog
   module Profiling
     module TraceIdentifiers
-      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (trace id and span id) for a
-      # given thread, if there is an active trace for that thread in Datadog.tracer.
+      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (root span id and span id)
+      # for a given thread, if there is an active trace for that thread in the supplied tracer object.
       class Ddtrace
-        def initialize(tracer: nil)
+        def initialize(tracer:)
           @tracer = (tracer if tracer.respond_to?(:call_context))
         end
 
@@ -19,10 +19,13 @@ module Datadog
           context = @tracer.call_context(thread)
           return unless context
 
-          trace_id = context.trace_id || 0
-          span_id = context.span_id || 0
+          span, root_span = context.current_span_and_root_span
+          return unless span && root_span
 
-          [trace_id, span_id, maybe_extract_resource(context.current_root_span)] if trace_id != 0 && span_id != 0
+          root_span_id = root_span.span_id || 0
+          span_id = span.span_id || 0
+
+          [root_span_id, span_id, maybe_extract_resource(root_span)] if root_span_id != 0 && span_id != 0
         end
 
         private
@@ -31,9 +34,7 @@ module Datadog
         # Resources MUST NOT include personal identifiable information (PII); this should not be the case with
         # ddtrace integrations, but worth mentioning just in case :)
         def maybe_extract_resource(root_span)
-          return unless root_span
-
-          root_span.resource_container if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
+          root_span.resource if root_span.span_type == Datadog::Ext::HTTP::TYPE_INBOUND
         end
       end
     end

data/lib/ddtrace/profiling/trace_identifiers/helper.rb

@@ -6,7 +6,7 @@ require 'ddtrace/profiling/trace_identifiers/ddtrace'
 module Datadog
   module Profiling
     module TraceIdentifiers
-      # Helper used to retrieve the trace identifiers (trace id and span id) for a given thread,
+      # Helper used to retrieve the trace identifiers (root span id and span id) for a given thread,
       # if there is an active trace for that thread for the supported tracing APIs.
       #
       # This data is used to connect profiles to the traces -- samples in a profile will be tagged with this data and
@@ -20,21 +20,21 @@ module Datadog
         def initialize(
           tracer:,
           # If this is disabled, the helper will strip the optional trace_resource_container even if provided by the api
-          extract_trace_resource:,
+          endpoint_collection_enabled:,
           supported_apis: DEFAULT_SUPPORTED_APIS.map { |api| api.new(tracer: tracer) }
         )
-          @extract_trace_resource = extract_trace_resource
+          @endpoint_collection_enabled = endpoint_collection_enabled
           @supported_apis = supported_apis
         end
 
         # Expected output of the #trace_identifiers_for
-        # duck type is [trace_id, span_id, (optional trace_resource_container)]
+        # duck type is [root_span_id, span_id, (optional trace_resource_container)]
         def trace_identifiers_for(thread)
           @supported_apis.each do |api|
             trace_identifiers = api.trace_identifiers_for(thread)
 
             if trace_identifiers
-              return @extract_trace_resource ? trace_identifiers : trace_identifiers[0..1]
+              return @endpoint_collection_enabled ? trace_identifiers : trace_identifiers[0..1]
             end
           end
 

data/lib/ddtrace/profiling/transport/http/api/endpoint.rb

@@ -41,11 +41,10 @@ module Datadog
 
             def build_form(env)
               flush = env.request.parcel.data
-              pprof_file, types = build_pprof(flush)
+              pprof_file = build_pprof(flush)
 
               form = {
-                # NOTE: Redundant w/ 'runtime-id' tag below; may want to remove this later.
-                FORM_FIELD_RUNTIME_ID => flush.runtime_id,
+                FORM_FIELD_INTAKE_VERSION => '3', # Aka 1.3 intake format
                 FORM_FIELD_RECORDING_START => flush.start.utc.iso8601,
                 FORM_FIELD_RECORDING_END => flush.finish.utc.iso8601,
                 FORM_FIELD_TAGS => [
@@ -64,14 +63,10 @@ module Datadog
                     .reject { |tag_key| TAGS_TO_IGNORE_IN_TAGS_HASH.include?(tag_key) }
                     .map { |tag_key, tag_value| "#{tag_key}:#{tag_value}" }
                 ],
-                FORM_FIELD_DATA => pprof_file,
-                FORM_FIELD_RUNTIME => flush.language,
-                FORM_FIELD_FORMAT => FORM_FIELD_FORMAT_PPROF
+                FORM_FIELD_PPROF_DATA => pprof_file,
+                FORM_FIELD_FAMILY => flush.language,
               }
 
-              # Add types
-              form[FORM_FIELD_TYPES] = types.join(',')
-
               # Optional fields
               form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_SERVICE}:#{flush.service}" unless flush.service.nil?
               form[FORM_FIELD_TAGS] << "#{FORM_FIELD_TAG_ENV}:#{flush.env}" unless flush.env.nil?
@@ -83,15 +78,13 @@ module Datadog
             def build_pprof(flush)
               pprof = encoder.encode(flush)
 
-              # Wrap pprof as a gzipped file
-              gzipped_data = Datadog::Utils::Compression.gzip(pprof.data)
-              pprof_file = Datadog::Vendor::Multipart::Post::UploadIO.new(
-                StringIO.new(gzipped_data),
+              gzipped_pprof_data = Datadog::Utils::Compression.gzip(pprof.data)
+
+              Datadog::Vendor::Multipart::Post::UploadIO.new(
+                StringIO.new(gzipped_pprof_data),
                 HEADER_CONTENT_TYPE_OCTET_STREAM,
                 PPROF_DEFAULT_FILENAME
               )
-
-              [pprof_file, [FORM_FIELD_TYPES_AUTO]]
             end
           end
         end

data/lib/ddtrace/profiling/transport/http.rb

@@ -64,22 +64,10 @@ module Datadog
           end
         end
 
-        private_class_method def self.default_adapter
-          :net_http
-        end
-
         private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
           apis = API.agent_defaults
 
-          transport.adapter(
-            default_adapter,
-            agent_settings.hostname,
-            agent_settings.port,
-            # We explictly use profiling_upload_timeout_seconds instead of agent_settings.timeout because profile
-            # uploads are bigger and thus we employ a separate configuration.
-            timeout: profiling_upload_timeout_seconds,
-            ssl: agent_settings.ssl
-          )
+          transport.adapter(agent_settings.merge(timeout_seconds: profiling_upload_timeout_seconds))
           transport.api(API::V1, apis[API::V1], default: true)
 
           # NOTE: This proc, when it exists, usually overrides the transport specified above
@@ -96,7 +84,7 @@ module Datadog
           port = site_uri.port
 
           transport.adapter(
-            default_adapter,
+            Datadog::Ext::Transport::HTTP::ADAPTER,
             hostname,
             port,
             timeout: profiling_upload_timeout_seconds,
@@ -111,9 +99,12 @@ module Datadog
         end
 
         # Add adapters to registry
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, :net_http)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, :test)
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, :unix)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net,
+                                                        Datadog::Ext::Transport::HTTP::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test,
+                                                        Datadog::Ext::Transport::Test::ADAPTER)
+        Datadog::Transport::HTTP::Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket,
+                                                        Datadog::Ext::Transport::UnixSocket::ADAPTER)
       end
     end
   end

data/lib/ddtrace/profiling.rb

@@ -128,9 +128,7 @@ module Datadog
     private_class_method def self.load_profiling
       return false unless supported?
 
-      require 'ddtrace/profiling/ext/cpu'
       require 'ddtrace/profiling/ext/forking'
-
       require 'ddtrace/profiling/collectors/stack'
       require 'ddtrace/profiling/exporter'
       require 'ddtrace/profiling/recorder'

data/lib/ddtrace/runtime/metrics.rb

@@ -7,6 +7,7 @@ require 'datadog/core/environment/class_count'
 require 'datadog/core/environment/gc'
 require 'datadog/core/environment/identity'
 require 'datadog/core/environment/thread_count'
+require 'datadog/core/environment/vm_cache'
 
 module Datadog
   module Runtime
@@ -58,12 +59,25 @@ module Datadog
             gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
           end
         end
+
         try_flush do
           if Core::Environment::ThreadCount.available?
             gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
           end
         end
+
         try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
+
+        try_flush do
+          if Core::Environment::VMCache.available?
+            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_CONSTANT_STATE, Core::Environment::VMCache.global_constant_state)
+
+            # global_method_state is not available since Ruby >= 3.0,
+            # as method caching was moved to a per-class basis.
+            global_method_state = Core::Environment::VMCache.global_method_state
+            gauge(Ext::Runtime::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
+          end
+        end
       end
 
       def gc_metrics

data/lib/ddtrace/sampler.rb

@@ -194,6 +194,12 @@ module Datadog
   class PrioritySampler
     extend Forwardable
 
+    # NOTE: We do not advise using a pre-sampler. It can save resources,
+    # but pre-sampling at rates < 100% may result in partial traces, unless
+    # the pre-sampler knows exactly how to drop a span without dropping its ancestors.
+    #
+    # Additionally, as service metrics are calculated in the Datadog Agent,
+    # the service's throughput will be underestimated.
     attr_reader :pre_sampler, :priority_sampler
 
     SAMPLE_RATE_METRIC_KEY = '_sample_rate'.freeze
@@ -209,17 +215,21 @@ module Datadog
 
     def sample!(span)
       # If pre-sampling is configured, do it first. (By default, this will sample at 100%.)
-      # NOTE: Pre-sampling at rates < 100% may result in partial traces; not recommended.
       span.sampled = pre_sample?(span) ? @pre_sampler.sample!(span) : true
 
       if span.sampled
-        # If priority sampling has already been applied upstream, use that, otherwise...
-        unless priority_assigned_upstream?(span)
-          # Roll the dice and determine whether how we set the priority.
-          priority = priority_sample!(span) ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+        # If priority sampling has already been applied upstream, use that value.
+        return true if priority_assigned?(span)
 
-          assign_priority!(span, priority)
-        end
+        # Check with post sampler how we set the priority.
+        sample = priority_sample!(span)
+
+        # Check if post sampler has already assigned a priority.
+        return true if priority_assigned?(span)
+
+        # If not, use agent priority values.
+        priority = sample ? Datadog::Ext::Priority::AUTO_KEEP : Datadog::Ext::Priority::AUTO_REJECT
+        assign_priority!(span, priority)
       else
         # If discarded by pre-sampling, set "reject" priority, so other
         # services for the same trace don't sample needlessly.
@@ -244,7 +254,7 @@ module Datadog
       end
     end
 
-    def priority_assigned_upstream?(span)
+    def priority_assigned?(span)
       span.context && !span.context.sampling_priority.nil?
     end
 

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -97,11 +97,13 @@ module Datadog
         sampled = rule.sample?(span)
         sample_rate = rule.sample_rate(span)
 
+        set_priority(span, sampled)
         set_rule_metrics(span, sample_rate)
 
         return false unless sampled
 
-        rate_limiter.allow?(1).tap do
+        rate_limiter.allow?(1).tap do |allowed|
+          set_priority(span, allowed)
           set_limiter_metrics(span, rate_limiter.effective_rate)
         end
       rescue StandardError => e
@@ -109,6 +111,16 @@ module Datadog
         yield(span)
       end
 
+      # Span priority should only be set when the {RuleSampler}
+      # was responsible for the sampling decision.
+      def set_priority(span, sampled)
+        if sampled
+          ForcedTracing.keep(span)
+        else
+          ForcedTracing.drop(span)
+        end
+      end
+
       def set_rule_metrics(span, sample_rate)
         span.set_metric(Ext::Sampling::RULE_SAMPLE_RATE, sample_rate)
       end

data/lib/ddtrace/span.rb

@@ -53,12 +53,7 @@ module Datadog
       Ext::NET::TAG_HOSTNAME => true
     }.freeze
 
-    # Simple indirection used to contain the latest resource name for a span.
-    # The profiler keeps a reference to these objects while sampling so it can extract the latest resource after the
-    # fact, as some integrations only set the correct name at the end of the span.
-    ResourceContainer = Struct.new(:latest)
-
-    attr_accessor :name, :service, :span_type,
+    attr_accessor :name, :service, :resource, :span_type,
                   :span_id, :trace_id, :parent_id,
                   :status, :sampled,
                   :tracer, :context
@@ -71,7 +66,8 @@ module Datadog
     # and then <tt>finish()</tt> once the tracer operation is over.
     #
     # * +service+: the service name for this span
-    # * +resource+: the resource this span refers, or +name+ if it's missing
+    # * +resource+: the resource this span refers, or +name+ if it's missing.
+    #     +nil+ can be used as a placeholder, when the resource value is not yet known at +#initialize+ time.
     # * +span_type+: the type of the span (such as +http+, +db+ and so on)
     # * +parent_id+: the identifier of the parent span
     # * +trace_id+: the identifier of the root span for this trace
@@ -81,7 +77,7 @@ module Datadog
 
       @name = name
       @service = options.fetch(:service, nil)
-      @resource_container = ResourceContainer.new(options.fetch(:resource, name))
+      @resource = options.fetch(:resource, name)
       @span_type = options.fetch(:span_type, nil)
 
       @span_id = Datadog::Utils.next_id
@@ -289,7 +285,7 @@ module Datadog
         trace_id: @trace_id,
         name: @name,
         service: @service,
-        resource: resource,
+        resource: @resource,
         type: @span_type,
         meta: @meta,
         metrics: @metrics,
@@ -343,7 +339,7 @@ module Datadog
       packer.write('service')
       packer.write(@service)
       packer.write('resource')
-      packer.write(resource)
+      packer.write(@resource)
       packer.write('type')
       packer.write(@span_type)
       packer.write('meta')
@@ -375,7 +371,7 @@ module Datadog
         q.text "Trace ID: #{@trace_id}\n"
         q.text "Type: #{@span_type}\n"
         q.text "Service: #{@service}\n"
-        q.text "Resource: #{resource}\n"
+        q.text "Resource: #{@resource}\n"
         q.text "Error: #{@status}\n"
         q.text "Start: #{start_time}\n"
         q.text "End: #{end_time}\n"
@@ -414,14 +410,6 @@ module Datadog
       end
     end
 
-    def resource
-      @resource_container.latest
-    end
-
-    def resource=(resource)
-      @resource_container.latest = resource
-    end
-
     private
 
     def duration_marker

data/lib/ddtrace/tracer.rb

@@ -200,7 +200,7 @@ module Datadog
       if parent.nil?
         # root span
         @sampler.sample!(span)
-        span.set_tag('system.pid', Process.pid)
+        span.set_tag(Datadog::Ext::Runtime::TAG_PID, Process.pid)
         span.set_tag(Datadog::Ext::Runtime::TAG_ID, Datadog::Core::Environment::Identity.id)
 
         if ctx && ctx.trace_id

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -16,13 +16,23 @@ module Datadog
 
           DEFAULT_TIMEOUT = 30
 
-          def initialize(hostname, port, options = {})
-            @hostname = hostname
-            @port = port
+          # @deprecated Positional parameters are deprecated. Use named parameters instead.
+          def initialize(hostname = nil, port = nil, **options)
+            @hostname = hostname || options.fetch(:hostname)
+            @port = port || options.fetch(:port)
             @timeout = options[:timeout] || DEFAULT_TIMEOUT
             @ssl = options.key?(:ssl) ? options[:ssl] == true : false
           end
 
+          def self.build(agent_settings)
+            new(
+              hostname: agent_settings.hostname,
+              port: agent_settings.port,
+              timeout: agent_settings.timeout_seconds,
+              ssl: agent_settings.ssl
+            )
+          end
+
           def open(&block)
             # DEV Initializing +Net::HTTP+ directly help us avoid expensive
             # options processing done in +Net::HTTP.start+:

data/lib/ddtrace/transport/http/adapters/test.rb

@@ -11,8 +11,10 @@ module Datadog
             :buffer,
             :status
 
-          def initialize(buffer = nil)
-            @buffer = buffer
+          # @param buffer [Array] an optional array that will capture all spans sent to this adapter, defaults to +nil+
+          # @deprecated Positional parameters are deprecated. Use named parameters instead.
+          def initialize(buffer = nil, **options)
+            @buffer = buffer || options[:buffer]
             @mutex = Mutex.new
             @status = 200
           end