ddtrace 0.46.0 → 0.51.0

data/lib/ddtrace/profiling/transport/io/client.rb

@@ -0,0 +1,27 @@
+require 'ddtrace/transport/io/client'
+require 'ddtrace/profiling/transport/client'
+require 'ddtrace/profiling/transport/request'
+require 'ddtrace/profiling/transport/io/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      module IO
+        # IO transport for profiling
+        class Client < Datadog::Transport::IO::Client
+          include Transport::Client
+
+          def send_profiling_flush(flush)
+            # Build a request
+            request = Profiling::Transport::Request.new(flush)
+            send_request(request)
+          end
+
+          def build_response(_request, _data, result)
+            Profiling::Transport::IO::Response.new(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/profiling/transport/io/response.rb

@@ -0,0 +1,16 @@
+require 'ddtrace/transport/io/response'
+require 'ddtrace/profiling/transport/response'
+
+module Datadog
+  module Profiling
+    module Transport
+      # IO transport behavior for profiling
+      module IO
+        # Response from IO transport for profiling
+        class Response < Datadog::Transport::IO::Response
+          include Profiling::Transport::Response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'ddtrace/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Data transfer object for profiling data
+      class Parcel
+        include Datadog::Transport::Parcel
+
+        def encode_with(encoder)
+          # TODO: Determine encoding behavior
+          encoder.encode(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'ddtrace/transport/request'
+require 'ddtrace/profiling/transport/parcel'
+
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling request
+      class Request < Datadog::Transport::Request
+        def initialize(flush)
+          super(Parcel.new(flush))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Datadog
+  module Profiling
+    module Transport
+      # Profiling response
+      module Response; end
+    end
+  end
+end

data/lib/ddtrace/runtime/metrics.rb

@@ -2,16 +2,16 @@ require 'ddtrace/ext/integration'
 require 'ddtrace/ext/runtime'
 
 require 'ddtrace/metrics'
-require 'ddtrace/runtime/class_count'
-require 'ddtrace/runtime/gc'
-require 'ddtrace/runtime/identity'
-require 'ddtrace/runtime/thread_count'
+require 'datadog/core/environment/class_count'
+require 'datadog/core/environment/gc'
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/thread_count'
 
 module Datadog
   module Runtime
     # For generating runtime metrics
     class Metrics < Datadog::Metrics
-      def initialize(options = {})
+      def initialize(**options)
         super
 
         # Initialize service list
@@ -29,7 +29,7 @@ module Datadog
         # Tag span with language and runtime ID for association with metrics.
         # We only tag spans that performed internal application work.
         unless span.get_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE)
-          span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
+          span.set_tag(Ext::Runtime::TAG_LANG, Core::Environment::Identity.lang)
         end
       end
 
@@ -52,17 +52,23 @@ module Datadog
       def flush
         return unless enabled?
 
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
-        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+        try_flush do
+          if Core::Environment::ClassCount.available?
+            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? }
       end
 
       def gc_metrics
-        Hash[
-          GC.stat.flat_map do |k, v|
-            nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
-          end
-        ]
+        Core::Environment::GC.stat.flat_map do |k, v|
+          nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
+        end.to_h
       end
 
       def try_flush

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -5,6 +5,7 @@ require 'ddtrace/ext/priority'
 require 'ddtrace/ext/sampling'
 require 'ddtrace/sampler'
 require 'ddtrace/sampling/rate_limiter'
+require 'ddtrace/sampling/rule'
 
 module Datadog
   module Sampling
@@ -45,15 +46,8 @@ module Datadog
         @default_sampler = if default_sampler
                              default_sampler
                            elsif default_sample_rate
-                             # We want to allow 0.0 to drop all traces, but \RateSampler
-                             # considers 0.0 an invalid rate and falls back to 100% sampling.
-                             #
-                             # We address that here by not setting the rate in the constructor,
-                             # but using the setter method.
-                             #
-                             # We don't want to make this change directly to \RateSampler
-                             # because it breaks its current contract to existing users.
-                             Datadog::RateSampler.new.tap { |s| s.sample_rate = default_sample_rate }
+                             # Add to the end of the rule list a rule always matches any span
+                             @rules << SimpleRule.new(sample_rate: default_sample_rate)
                            else
                              RateByServiceSampler.new(1.0, env: -> { Datadog.tracer.tags[:env] })
                            end

data/lib/ddtrace/span.rb

@@ -2,9 +2,12 @@
 
 require 'time'
 require 'ddtrace/utils'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/ext/environment'
 require 'ddtrace/ext/errors'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/net'
 require 'ddtrace/ext/priority'
-require 'ddtrace/environment'
 require 'ddtrace/analytics'
 require 'ddtrace/forced_tracing'
 require 'ddtrace/diagnostics/health'
@@ -38,6 +41,17 @@ module Datadog
     # This limit is for numeric tags because uint64 could end up rounded.
     NUMERIC_TAG_SIZE_RANGE = (-1 << 53..1 << 53).freeze
 
+    # Some associated values should always be sent as Tags, never as Metrics, regardless
+    # if their value is numeric or not.
+    # The Datadog agent will look for these values only as Tags, not Metrics.
+    # @see https://github.com/DataDog/datadog-agent/blob/2ae2cdd315bcda53166dd8fa0dedcfc448087b9d/pkg/trace/stats/aggregation.go#L13-L17
+    ENSURE_AGENT_TAGS = {
+      Ext::DistributedTracing::ORIGIN_KEY => true,
+      Ext::Environment::TAG_VERSION => true,
+      Ext::HTTP::STATUS_CODE => true,
+      Ext::NET::TAG_HOSTNAME => true
+    }.freeze
+
     attr_accessor :name, :service, :resource, :span_type,
                   :span_id, :trace_id, :parent_id,
                   :status, :sampled,
@@ -101,11 +115,8 @@ module Datadog
       # Keys must be unique between tags and metrics
       @metrics.delete(key)
 
-      # Ensure `http.status_code` is always a string so it is added to
-      #   @meta instead of @metrics
-      # DEV: This is necessary because the agent looks to `meta['http.status_code']` for
-      #   tagging necessary metrics
-      value = value.to_s if key == Ext::HTTP::STATUS_CODE
+      # DEV: This is necessary because the agent looks at `meta[key]`, not `metrics[key]`.
+      value = value.to_s if ENSURE_AGENT_TAGS[key]
 
       # NOTE: Adding numeric tags as metrics is stop-gap support
       #       for numeric typed tags. Eventually they will become

data/lib/ddtrace/sync_writer.rb

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/net'
-require 'ddtrace/runtime/socket'
+require 'datadog/core/environment/socket'
 require 'ddtrace/runtime/metrics'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   # SyncWriter flushes both services and traces synchronously
@@ -10,6 +11,8 @@ module Datadog
   # the separate `datadog-lambda` uses it as of February 2021:
   # <https://github.com/DataDog/datadog-lambda-rb/blob/c15f0f0916c90123416dc44e7d6800ef4a7cfdbf/lib/datadog/lambda.rb#L38>
   class SyncWriter
+    DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     attr_reader \
       :priority_sampler,
       :transport
@@ -17,7 +20,8 @@ module Datadog
     def initialize(options = {})
       @transport = options.fetch(:transport) do
         transport_options = options.fetch(:transport_options, {})
-        Transport::HTTP.default(transport_options)
+        transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
+        Transport::HTTP.default(**transport_options)
       end
 
       @priority_sampler = options.fetch(:priority_sampler, nil)
@@ -25,10 +29,10 @@ module Datadog
 
     def write(trace, services = nil)
       unless services.nil?
-        Datadog::Patcher.do_once('SyncWriter#write') do
+        DEPRECATION_WARN_ONLY_ONCE.run do
           Datadog.logger.warn(%(
             write: Writing services has been deprecated and no longer need to be provided.
-            write(traces, services) can be updted to write(traces)
+            write(traces, services) can be updated to write(traces)
           ))
         end
       end
@@ -56,7 +60,7 @@ module Datadog
 
     def inject_hostname!(trace)
       unless trace.first.nil?
-        hostname = Datadog::Runtime::Socket.hostname
+        hostname = Datadog::Core::Environment::Socket.hostname
         trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
       end
     end

data/lib/ddtrace/tasks/exec.rb

@@ -0,0 +1,48 @@
+module Datadog
+  module Tasks
+    # Wraps command with Datadog tracing
+    class Exec
+      attr_reader :args
+
+      def initialize(args)
+        @args = args
+      end
+
+      def run
+        set_rubyopt!
+        exec_with_error_handling(args)
+      end
+
+      def rubyopts
+        [
+          '-rddtrace/profiling/preload'
+        ]
+      end
+
+      private
+
+      def set_rubyopt!
+        if ENV.key?('RUBYOPT')
+          ENV['RUBYOPT'] += " #{rubyopts.join(' ')}"
+        else
+          ENV['RUBYOPT'] = rubyopts.join(' ')
+        end
+      end
+
+      # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
+      # follow the same status codes as the shell uses
+      # See also:
+      # * https://www.gnu.org/software/bash/manual/html_node/Exit-Status.html
+      # * https://github.com/rubygems/rubygems/blob/dd93966cac224532035deda533cba2685dfa30cc/bundler/lib/bundler/cli/exec.rb#L45
+      def exec_with_error_handling(args)
+        Kernel.exec(*args)
+      rescue Errno::ENOENT => e
+        Kernel.warn "ddtracerb exec failed: #{e.message} (command was '#{args.join(' ')}')"
+        Kernel.exit 127
+      rescue Errno::EACCES, Errno::ENOEXEC => e
+        Kernel.warn "ddtracerb exec failed: #{e.message} (command was '#{args.join(' ')}')"
+        Kernel.exit 126
+      end
+    end
+  end
+end

data/lib/ddtrace/tasks/help.rb

@@ -0,0 +1,14 @@
+module Datadog
+  module Tasks
+    # Prints help message for usage of `ddtrace`
+    class Help
+      def run
+        puts %(
+Usage: ddtrace [command] [arguments]
+  exec [command]: Executes command with tracing & profiling preloaded.
+  help:           Prints this help message.
+        )
+      end
+    end
+  end
+end

data/lib/ddtrace/tracer.rb

@@ -1,15 +1,17 @@
 require 'logger'
 require 'pathname'
 
-require 'ddtrace/environment'
+require 'ddtrace/ext/environment'
 require 'ddtrace/span'
 require 'ddtrace/context'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
-require 'ddtrace/runtime/identity'
+require 'datadog/core/environment/identity'
 require 'ddtrace/sampler'
 require 'ddtrace/sampling'
 require 'ddtrace/correlation'
+require 'ddtrace/event'
+require 'ddtrace/utils/only_once'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -19,6 +21,9 @@ module Datadog
   # of these function calls and sub-requests would be encapsulated within a single trace.
   # rubocop:disable Metrics/ClassLength
   class Tracer
+    SERVICES_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     attr_reader :sampler, :tags, :provider, :context_flush
     attr_accessor :enabled, :writer
     attr_writer :default_service
@@ -27,8 +32,7 @@ module Datadog
     DEFAULT_ON_ERROR = proc { |span, error| span.set_error(error) unless span.nil? }
 
     def services
-      # Only log each deprecation warning once (safeguard against log spam)
-      Datadog::Patcher.do_once('Tracer#set_service_info') do
+      SERVICES_DEPRECATION_WARN_ONLY_ONCE.run do
         Datadog.logger.warn('services: Usage of Tracer.services has been deprecated')
       end
 
@@ -70,7 +74,9 @@ module Datadog
     #   by default.
     def initialize(options = {})
       # Configurable options
-      @context_flush = if options[:partial_flush]
+      @context_flush = if options[:context_flush]
+                         options[:context_flush]
+                       elsif options[:partial_flush]
                          Datadog::ContextFlush::Partial.new(options)
                        else
                          Datadog::ContextFlush::Finished.new
@@ -81,7 +87,7 @@ module Datadog
       @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
       @sampler = options.fetch(:sampler, Datadog::AllSampler.new)
       @tags = options.fetch(:tags, {})
-      @writer = options.fetch(:writer, Datadog::Writer.new)
+      @writer = options.fetch(:writer) { Datadog::Writer.new }
 
       # Instance variables
       @mutex = Mutex.new
@@ -114,8 +120,10 @@ module Datadog
 
       configure_writer(options)
 
-      if options.key?(:partial_flush)
-        @context_flush = if options[:partial_flush]
+      if options.key?(:context_flush) || options.key?(:partial_flush)
+        @context_flush = if options[:context_flush]
+                           options[:context_flush]
+                         elsif options[:partial_flush]
                            Datadog::ContextFlush::Partial.new(options)
                          else
                            Datadog::ContextFlush::Finished.new
@@ -129,8 +137,7 @@ module Datadog
     #
     # set_service_info is deprecated, no service information needs to be tracked
     def set_service_info(service, app, app_type)
-      # Only log each deprecation warning once (safeguard against log spam)
-      Datadog::Patcher.do_once('Tracer#set_service_info') do
+      SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE.run do
         Datadog.logger.warn(%(
           set_service_info: Usage of set_service_info has been deprecated,
           service information no longer needs to be reported to the trace agent.
@@ -142,15 +149,7 @@ module Datadog
     # for non-root spans which have a parent. However, root spans without
     # a service would be invalid and rejected.
     def default_service
-      return @default_service if instance_variable_defined?(:@default_service) && @default_service
-
-      begin
-        @default_service = File.basename($PROGRAM_NAME, '.*')
-      rescue StandardError => e
-        Datadog.logger.error("unable to guess default service: #{e}")
-        @default_service = 'ruby'.freeze
-      end
-      @default_service
+      @default_service ||= Datadog::Ext::Environment::FALLBACK_SERVICE_NAME
     end
 
     # Set the given key / value tag pair at the tracer level. These tags will be
@@ -159,7 +158,7 @@ module Datadog
     #
     #   tracer.set_tags('env' => 'prod', 'component' => 'core')
     def set_tags(tags)
-      string_tags = Hash[tags.collect { |k, v| [k.to_s, v] }]
+      string_tags = tags.collect { |k, v| [k.to_s, v] }.to_h
       @tags = @tags.merge(string_tags)
     end
 
@@ -202,7 +201,7 @@ module Datadog
         # root span
         @sampler.sample!(span)
         span.set_tag('system.pid', Process.pid)
-        span.set_tag(Datadog::Ext::Runtime::TAG_ID, Datadog::Runtime::Identity.id)
+        span.set_tag(Datadog::Ext::Runtime::TAG_ID, Datadog::Core::Environment::Identity.id)
 
         if ctx && ctx.trace_id
           span.trace_id = ctx.trace_id
@@ -313,6 +312,10 @@ module Datadog
       end
     end
 
+    def trace_completed
+      @trace_completed ||= TraceCompleted.new
+    end
+
     # Record the given +context+. For compatibility with previous versions,
     # +context+ can also be a span. It is similar to the +child_of+ argument,
     # method will figure out what to do, submitting a +span+ for recording
@@ -364,24 +367,34 @@ module Datadog
       end
 
       @writer.write(trace)
+      trace_completed.publish(trace)
+    end
+
+    # Triggered whenever a trace is completed
+    class TraceCompleted < Datadog::Event
+      def initialize
+        super(:trace_completed)
+      end
+
+      # NOTE: Ignore Rubocop rule. This definition allows for
+      #       description of and constraints on arguments.
+      # rubocop:disable Lint/UselessMethodDefinition
+      def publish(trace)
+        super(trace)
+      end
+      # rubocop:enable Lint/UselessMethodDefinition
     end
 
     # TODO: Move this kind of configuration building out of the tracer.
     #       Tracer should not have this kind of knowledge of writer.
-    # rubocop:disable Metrics/PerceivedComplexity
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/MethodLength
     def configure_writer(options = {})
-      hostname = options.fetch(:hostname, nil)
-      port = options.fetch(:port, nil)
       sampler = options.fetch(:sampler, nil)
       priority_sampling = options.fetch(:priority_sampling, nil)
       writer = options.fetch(:writer, nil)
-      transport_options = options.fetch(:transport_options, {}).dup
+      agent_settings = options.fetch(:agent_settings, nil)
 
       # Compile writer options
       writer_options = options.fetch(:writer_options, {}).dup
-      rebuild_writer = !writer_options.empty?
 
       # Re-build the sampler and writer if priority sampling is enabled,
       # but neither are configured. Verify the sampler isn't already a
@@ -394,35 +407,20 @@ module Datadog
         end
       elsif priority_sampling != false && !@sampler.is_a?(PrioritySampler)
         writer_options[:priority_sampler] = activate_priority_sampling!(@sampler)
-        rebuild_writer = true
       elsif priority_sampling == false
         deactivate_priority_sampling!(sampler)
-        rebuild_writer = true
       elsif @sampler.is_a?(PrioritySampler)
         # Make sure to add sampler to options if transport is rebuilt.
         writer_options[:priority_sampler] = @sampler
       end
 
-      # Apply options to transport
-      if transport_options.is_a?(Proc)
-        transport_options = { on_build: transport_options }
-        rebuild_writer = true
-      end
+      writer_options[:agent_settings] = agent_settings if agent_settings
 
-      if hostname || port
-        transport_options[:hostname] = hostname unless hostname.nil?
-        transport_options[:port] = port unless port.nil?
-        rebuild_writer = true
-      end
-
-      writer_options[:transport_options] = transport_options
+      # Make sure old writer is shut down before throwing away.
+      # Don't want additional threads running...
+      @writer.stop unless writer.nil?
 
-      if rebuild_writer || writer
-        # Make sure old writer is shut down before throwing away.
-        # Don't want additional threads running...
-        @writer.stop unless writer.nil?
-        @writer = writer || Writer.new(writer_options)
-      end
+      @writer = writer || Writer.new(writer_options)
     end
 
     def activate_priority_sampling!(base_sampler = nil)