ddtrace 0.44.0 → 0.48.0

data/lib/ddtrace/quantization/http.rb

@@ -61,6 +61,7 @@ module Datadog
       # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
       def collect_query(query, options = {})
         return query unless block_given?
+
         uniq = options[:uniq].nil? ? false : options[:uniq]
         keys = Set.new
 

data/lib/ddtrace/runtime/cgroup.rb

@@ -4,7 +4,7 @@ module Datadog
   module Runtime
     # For control groups
     module Cgroup
-      LINE_REGEX = /^(\d+):([^:]*):(.+)$/
+      LINE_REGEX = /^(\d+):([^:]*):(.+)$/.freeze
 
       Descriptor = Struct.new(
         :id,
@@ -21,7 +21,7 @@ module Datadog
             filepath = "/proc/#{process}/cgroup"
 
             if File.exist?(filepath)
-              File.open("/proc/#{process}/cgroup").each do |line|
+              File.foreach("/proc/#{process}/cgroup") do |line|
                 line = line.strip
                 descriptors << parse(line) unless line.empty?
               end

data/lib/ddtrace/runtime/container.rb

@@ -8,8 +8,9 @@ module Datadog
       UUID_PATTERN = '[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}'.freeze
       CONTAINER_PATTERN = '[0-9a-f]{64}'.freeze
 
-      POD_REGEX = /(pod)?(#{UUID_PATTERN})(?:.slice)?$/
-      CONTAINER_REGEX = /(#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/
+      POD_REGEX = /(pod)?(#{UUID_PATTERN})(?:.slice)?$/.freeze
+      CONTAINER_REGEX = /(#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/.freeze
+      FARGATE_14_CONTAINER_REGEX = /[0-9a-f]{32}-[0-9]{10}/.freeze
 
       Descriptor = Struct.new(
         :platform,
@@ -32,39 +33,44 @@ module Datadog
       end
 
       def descriptor
-        @descriptor ||= begin
-          Descriptor.new.tap do |descriptor|
-            begin
-              Cgroup.descriptors.each do |cgroup_descriptor|
-                # Parse container data from cgroup descriptor
-                path = cgroup_descriptor.path
-                next if path.nil?
+        @descriptor ||= Descriptor.new.tap do |descriptor|
+          begin
+            Cgroup.descriptors.each do |cgroup_descriptor|
+              # Parse container data from cgroup descriptor
+              path = cgroup_descriptor.path
+              next if path.nil?
 
-                # Split path into parts
-                parts = path.split('/')
-                parts.shift # Remove leading empty part
-                next if parts.length < 2
+              # Split path into parts
+              parts = path.split('/')
+              parts.shift # Remove leading empty part
 
-                # Read info from path
+              # Read info from path
+              platform = parts[0]
+              container_id, task_uid = nil
+
+              case parts.length
+              when 2
+                container_id = parts[-1][CONTAINER_REGEX] || parts[-1][FARGATE_14_CONTAINER_REGEX]
+              else
                 platform = parts[0]
                 container_id = parts[-1][CONTAINER_REGEX]
                 task_uid = parts[-2][POD_REGEX]
+              end
 
-                # If container ID wasn't found, ignore.
-                # Path might describe a non-container environment.
-                next if container_id.nil?
+              # If container ID wasn't found, ignore.
+              # Path might describe a non-container environment.
+              next if container_id.nil?
 
-                descriptor.platform = platform
-                descriptor.container_id = container_id
-                descriptor.task_uid = task_uid
+              descriptor.platform = platform
+              descriptor.container_id = container_id
+              descriptor.task_uid = task_uid
 
-                break
-              end
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
-              )
+              break
             end
+          rescue StandardError => e
+            Datadog.logger.error(
+              "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
+            )
           end
         end
       end

data/lib/ddtrace/runtime/identity.rb

@@ -24,10 +24,18 @@ module Datadog
         Ext::Runtime::LANG
       end
 
+      def lang_engine
+        Ext::Runtime::LANG_ENGINE
+      end
+
       def lang_interpreter
         Ext::Runtime::LANG_INTERPRETER
       end
 
+      def lang_platform
+        Ext::Runtime::LANG_PLATFORM
+      end
+
       def lang_version
         Ext::Runtime::LANG_VERSION
       end

data/lib/ddtrace/sampler.rb

@@ -81,7 +81,7 @@ module Datadog
       :default_key
 
     def initialize(default_key, default_rate = 1.0, &block)
-      raise ArgumentError, 'No resolver given!' unless block_given?
+      raise ArgumentError, 'No resolver given!' unless block
 
       @default_key = default_key
       @resolver = block

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
@@ -88,6 +82,7 @@ module Datadog
 
       def update(*args)
         return false unless @default_sampler.respond_to?(:update)
+
         @default_sampler.update(*args)
       end
 

data/lib/ddtrace/span.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'thread'
-
 require 'ddtrace/utils'
 require 'ddtrace/ext/errors'
 require 'ddtrace/ext/priority'
@@ -38,14 +36,16 @@ module Datadog
     EXTERNAL_MAX_ID = 1 << 64
 
     # This limit is for numeric tags because uint64 could end up rounded.
-    NUMERIC_TAG_SIZE_RANGE = (-1 << 53..1 << 53)
+    NUMERIC_TAG_SIZE_RANGE = (-1 << 53..1 << 53).freeze
 
     attr_accessor :name, :service, :resource, :span_type,
                   :span_id, :trace_id, :parent_id,
                   :status, :sampled,
-                  :tracer, :context, :duration, :start_time, :end_time
+                  :tracer, :context
+
+    attr_reader :parent, :start_time, :end_time
 
-    attr_reader :parent
+    attr_writer :duration
 
     # Create a new span linked to the given tracer. Call the \Tracer method <tt>start_span()</tt>
     # and then <tt>finish()</tt> once the tracer operation is over.
@@ -180,7 +180,7 @@ module Datadog
       # behavior and so we maintain it for backward compatibility for those
       # who are using async manual instrumentation that may rely on this
 
-      @start_time = start_time || Time.now.utc
+      @start_time = start_time || Utils::Time.now.utc
       @duration_start = start_time.nil? ? duration_marker : nil
 
       self
@@ -206,7 +206,7 @@ module Datadog
 
       @allocation_count_finish = now_allocations
 
-      now = Time.now.utc
+      now = Utils::Time.now.utc
 
       # Provide a default start_time if unset.
       # Using `now` here causes duration to be 0; this is expected

data/lib/ddtrace/sync_writer.rb

@@ -1,11 +1,18 @@
 require 'ddtrace/ext/net'
 require 'ddtrace/runtime/socket'
 require 'ddtrace/runtime/metrics'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   # SyncWriter flushes both services and traces synchronously
   # DEV: To be replaced by Datadog::Workers::TraceWriter.
+  #
+  # Note: If you're wondering if this class is used at all, since there are no other references to it on the codebase,
+  # 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
@@ -21,17 +28,15 @@ 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
 
-      perform_concurrently(
-        proc { flush_trace(trace) }
-      )
+      flush_trace(trace)
     rescue => e
       Datadog.logger.debug(e)
     end
@@ -44,13 +49,10 @@ module Datadog
 
     private
 
-    def perform_concurrently(*tasks)
-      tasks.map { |task| Thread.new(&task) }.each(&:join)
-    end
-
     def flush_trace(trace)
       processed_traces = Pipeline.process!([trace])
       return if processed_traces.empty?
+
       inject_hostname!(processed_traces.first) if Datadog.configuration.report_hostname
       transport.send_traces(processed_traces)
     end
@@ -58,9 +60,7 @@ module Datadog
     def inject_hostname!(trace)
       unless trace.first.nil?
         hostname = Datadog::Runtime::Socket.hostname
-        unless hostname.nil? || hostname.empty?
-          trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname)
-        end
+        trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
       end
     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,4 +1,3 @@
-require 'thread'
 require 'logger'
 require 'pathname'
 
@@ -11,6 +10,8 @@ require 'ddtrace/runtime/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
@@ -20,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
@@ -28,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
 
@@ -130,8 +133,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.
@@ -144,6 +146,7 @@ module Datadog
     # 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
@@ -313,6 +316,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,6 +371,22 @@ 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.

data/lib/ddtrace/transport/http.rb

@@ -27,7 +27,7 @@ module Datadog
       # Pass a block to override any settings.
       def default(options = {})
         new do |transport|
-          transport.adapter :net_http, default_hostname, default_port
+          transport.adapter default_adapter, default_hostname, default_port, timeout: 1
           transport.headers default_headers
 
           apis = API.defaults
@@ -39,10 +39,15 @@ module Datadog
           # Apply any settings given by options
           unless options.empty?
             # Change hostname/port
-            if options.key?(:hostname) || options.key?(:port)
-              hostname = options.fetch(:hostname, default_hostname)
-              port = options.fetch(:port, default_port)
-              transport.adapter :net_http, hostname, port
+            if [:hostname, :port, :timeout, :ssl].any? { |key| options.key?(key) }
+              hostname = options[:hostname] || default_hostname
+              port = options[:port] || default_port
+
+              adapter_options = { timeout: 1 }
+              adapter_options[:timeout] = options[:timeout] if options.key?(:timeout)
+              adapter_options[:ssl] = options[:ssl] if options.key?(:ssl)
+
+              transport.adapter default_adapter, hostname, port, adapter_options
             end
 
             # Change default API
@@ -69,12 +74,14 @@ module Datadog
         }.tap do |headers|
           # Add container ID, if present.
           container_id = Datadog::Runtime::Container.container_id
-          unless container_id.nil?
-            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id
-          end
+          headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
         end
       end
 
+      def default_adapter
+        :net_http
+      end
+
       def default_hostname
         return default_url.hostname if default_url