ddtrace 0.44.0 → 0.49.0

data/integration/images/ruby/3.0/Dockerfile

@@ -0,0 +1,54 @@
+FROM ruby:3.0
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install prerequisites
+RUN set -ex && \
+        echo "===> Installing dependencies" && \
+        apt-get -y update && \
+        apt-get install -y --force-yes --no-install-recommends \
+            curl wget tar gzip gnupg apt-transport-https ca-certificates tzdata locales && \
+        \
+        echo "===> Installing NodeJS" && \
+        apt-get install -y --force-yes --no-install-recommends nodejs && \
+        \
+        echo "===> Installing Yarn" && \
+        curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \
+        echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \
+        apt-get update && \
+        apt-get install -y --force-yes --no-install-recommends yarn && \
+        \
+        echo "===> Installing database libraries" && \
+        apt-get install -y --force-yes --no-install-recommends \
+            postgresql-client sqlite3 && \
+        \
+        echo "===> Installing dev tools" && \
+        mkdir -p /usr/share/man/man1 && \
+        apt-get install -y --force-yes --no-install-recommends \
+            sudo git openssh-client rsync vim \
+            net-tools netcat parallel unzip zip bzip2 && \
+        \
+        echo "===> Cleaning up" && \
+        rm -rf /var/lib/apt/lists/*;
+
+# Set timezone to UTC by default
+RUN ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime
+
+# Set language
+RUN locale-gen en_US.UTF-8
+ENV LANG en_US.UTF-8
+ENV LANGUAGE en_US:en
+
+# Install RubyGems
+RUN gem update --system
+RUN mkdir -p "$GEM_HOME" && chmod -R 777 "$GEM_HOME"
+
+# Upgrade RubyGems and Bundler
+RUN gem update --system
+RUN gem install bundler
+ENV BUNDLE_SILENCE_ROOT_WARNING 1
+
+# Setup demo environment includes
+COPY ./include /vendor/dd-demo
+ENV RUBYLIB /vendor/dd-demo
+ENV RUBYOPT -rdatadog/demo_env

data/integration/images/wrk/Dockerfile

@@ -0,0 +1,33 @@
+FROM debian:jessie
+
+RUN echo "===> Installing  tools..."  && \
+    apt-get -y update && \
+    apt-get -y install build-essential curl && \
+    \
+    echo "===> Installing wrk" && \
+    WRK_VERSION=$(curl -L https://github.com/wg/wrk/raw/master/CHANGES 2>/dev/null | \
+                  egrep '^wrk' | head -n 1 | awk '{print $2}') && \
+    echo $WRK_VERSION  && \
+    mkdir /opt/wrk && \
+    cd /opt/wrk && \
+    curl -L https://github.com/wg/wrk/archive/$WRK_VERSION.tar.gz | \
+       tar zx --strip 1 && \
+    make && \
+    cp wrk /usr/local/bin/ && \
+    \
+    echo "===> Cleaning the system" && \
+    apt-get -f -y --auto-remove remove build-essential && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* /opt/wrk/
+
+# Setup directory
+RUN mkdir /scripts
+RUN mkdir /data
+WORKDIR /scripts
+
+# Add scripts
+COPY ./include /vendor/dd-demo
+COPY ./wrk/scripts /scripts
+
+# Set entrypoint
+ENTRYPOINT ["./entrypoint.sh"]

data/integration/images/wrk/scripts/entrypoint.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+bash /vendor/dd-demo/http-health-check
+
+# Start the load test
+echo "== Starting load test... =="
+
+if [[ $# -eq 0 ]] ; then
+  echo "** No load test specified: pass wrk args as a command. **"
+  echo "== Load test aborted. =="
+  exit 1
+else
+  COMMAND="wrk $@"
+  echo "Command: $COMMAND"
+  /bin/bash -c "$COMMAND"
+  echo "== Load test done. =="
+  exit 0
+fi

data/integration/images/wrk/scripts/scenarios/basic/default.lua

@@ -0,0 +1 @@
+wrk.method = "GET"

data/integration/images/wrk/scripts/scenarios/basic/fibonacci.lua

@@ -0,0 +1 @@
+wrk.method = "GET"

data/integration/script/build-images

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+INTEGRATION_SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+INTEGRATION_DIR=${INTEGRATION_SCRIPT_DIR%/script}
+cd $INTEGRATION_DIR
+
+# Parse options
+while getopts ":v:" opt; do
+  case $opt in
+    v)
+      APP_RUBY_VERSION=$OPTARG
+      ;;
+    \?)
+      echo "Invalid option: -$OPTARG" >&2
+      exit 1
+      ;;
+    :)
+      echo "Option -$OPTARG requires an argument." >&2
+      exit 1
+      ;;
+  esac
+done
+
+echo "== Building base images... =="
+# "wrk" not necessary for CI: will be auto-built by local apps via docker-compose.
+# docker build -t datadog/dd-apm-demo:wrk -f $INTEGRATION_DIR/images/wrk/Dockerfile $INTEGRATION_DIR/images
+docker build -t datadog/dd-apm-demo:agent -f $INTEGRATION_DIR/images/agent/Dockerfile $INTEGRATION_DIR/images/agent
+
+if [ -v APP_RUBY_VERSION ]; then
+  docker build -t datadog/dd-apm-demo:rb-$APP_RUBY_VERSION -f $INTEGRATION_DIR/images/ruby/$APP_RUBY_VERSION/Dockerfile $INTEGRATION_DIR/images
+else
+  docker build -t datadog/dd-apm-demo:rb-2.0 -f $INTEGRATION_DIR/images/ruby/2.0/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.1 -f $INTEGRATION_DIR/images/ruby/2.1/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.2 -f $INTEGRATION_DIR/images/ruby/2.2/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.3 -f $INTEGRATION_DIR/images/ruby/2.3/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.4 -f $INTEGRATION_DIR/images/ruby/2.4/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.5 -f $INTEGRATION_DIR/images/ruby/2.5/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.6 -f $INTEGRATION_DIR/images/ruby/2.6/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-2.7 -f $INTEGRATION_DIR/images/ruby/2.7/Dockerfile $INTEGRATION_DIR/images
+  docker build -t datadog/dd-apm-demo:rb-3.0 -f $INTEGRATION_DIR/images/ruby/3.0/Dockerfile $INTEGRATION_DIR/images
+fi
+echo "== Done building base images. =="

data/lib/ddtrace.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 # During development, we load `ddtrace` by through `ddtrace.gemspec`,
 # which in turn eager loads 'ddtrace/version'.
 #
@@ -15,13 +13,14 @@ require 'ddtrace/quantization/http'
 require 'ddtrace/pipeline'
 require 'ddtrace/configuration'
 require 'ddtrace/patcher'
-require 'ddtrace/augmentation'
 require 'ddtrace/metrics'
+require 'ddtrace/auto_instrument_base'
+require 'ddtrace/profiling'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
-  extend Augmentation
   extend Configuration
+  extend AutoInstrumentBase
 
   # Load and extend Contrib by default
   require 'ddtrace/contrib/extensions'
@@ -31,6 +30,10 @@ module Datadog
   require 'ddtrace/opentelemetry/extensions'
   extend OpenTelemetry::Extensions
 
+  # Load and extend AutoInstrument
+  require 'ddtrace/contrib/auto_instrument'
+  extend Contrib::AutoInstrument
+
   # Add shutdown hook:
   # Ensures the tracer has an opportunity to flush traces
   # and cleanup before terminating the process.
@@ -56,6 +59,7 @@ require 'ddtrace/contrib/grape/integration'
 require 'ddtrace/contrib/graphql/integration'
 require 'ddtrace/contrib/grpc/integration'
 require 'ddtrace/contrib/http/integration'
+require 'ddtrace/contrib/httpclient/integration'
 require 'ddtrace/contrib/httprb/integration'
 require 'ddtrace/contrib/integration'
 require 'ddtrace/contrib/kafka/integration'
@@ -78,4 +82,3 @@ require 'ddtrace/contrib/sidekiq/integration'
 require 'ddtrace/contrib/sinatra/integration'
 require 'ddtrace/contrib/sneakers/integration'
 require 'ddtrace/contrib/sucker_punch/integration'
-require 'ddtrace/monkey'

data/lib/ddtrace/analytics.rb

@@ -6,11 +6,13 @@ module Datadog
     class << self
       def set_sample_rate(span, sample_rate)
         return if span.nil? || !sample_rate.is_a?(Numeric)
+
         span.set_metric(Datadog::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate)
       end
 
       def set_measured(span, value = true)
         return if span.nil?
+
         # rubocop:disable Style/MultipleComparison
         value = value == true || value == 1 ? 1 : 0
         span.set_metric(Datadog::Ext::Analytics::TAG_MEASURED, value)

data/lib/ddtrace/auto_instrument.rb

@@ -0,0 +1,3 @@
+require 'ddtrace'
+
+Datadog.add_auto_instrument

data/lib/ddtrace/auto_instrument_base.rb

@@ -0,0 +1,6 @@
+module Datadog
+  # base methods stubbed for adding auto instrument extensions
+  module AutoInstrumentBase
+    def add_auto_instrument; end
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'ddtrace/diagnostics/health'
 require 'ddtrace/runtime/object_space'
 
@@ -18,6 +17,7 @@ module Datadog
     # even if the buffer is full. In that case, a random item is discarded.
     def push(item)
       return if closed?
+
       full? ? replace!(item) : add!(item)
       item
     end
@@ -168,8 +168,8 @@ module Datadog
       synchronize { super }
     end
 
-    def synchronize
-      @mutex.synchronize { yield }
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
   end
 
@@ -318,7 +318,7 @@ module Datadog
   #
   # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
   # TODO Making such a change is potentially breaking for users manually configuring the tracer.
-  TraceBuffer = if Datadog::Ext::Runtime::RUBY_ENGINE == 'ruby' # rubocop:disable Style/ConstantName
+  TraceBuffer = if Datadog::Ext::Runtime::RUBY_ENGINE == 'ruby'
                   CRubyTraceBuffer
                 else
                   ThreadSafeTraceBuffer

data/lib/ddtrace/configuration.rb

@@ -1,14 +1,41 @@
 require 'forwardable'
-
 require 'ddtrace/configuration/pin_setup'
 require 'ddtrace/configuration/settings'
 require 'ddtrace/configuration/components'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   # Configuration provides a unique access point for configurations
-  module Configuration
+  module Configuration # rubocop:disable Metrics/ModuleLength
     extend Forwardable
 
+    # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
+    #
+    # This is important because components can end up being accessed from multiple application threads (for instance on
+    # a threaded webserver), and we don't want their initialization to clash (for instance, starting two profilers...).
+    #
+    # Note that a Mutex **IS NOT** reentrant: the same thread cannot grab the same Mutex more than once.
+    # This means below we are careful not to nest calls to methods that would trigger initialization and grab the lock.
+    #
+    # Every method that directly or indirectly mutates @components should be holding the lock (through
+    # #safely_synchronize) while doing so.
+    COMPONENTS_WRITE_LOCK = Mutex.new
+    private_constant :COMPONENTS_WRITE_LOCK
+
+    # We use a separate lock when reading the @components, so that they continue to be accessible during reconfiguration.
+    # This was needed because we ran into several issues where we still needed to read the old
+    # components while the COMPONENTS_WRITE_LOCK was being held (see https://github.com/DataDog/dd-trace-rb/pull/1387
+    # and https://github.com/DataDog/dd-trace-rb/pull/1373#issuecomment-799593022 ).
+    #
+    # Technically on MRI we could get away without this lock, but on non-MRI Rubies, we may run into issues because
+    # we fall into the "UnsafeDCLFactory" case of https://shipilev.net/blog/2014/safe-public-construction/ .
+    # Specifically, on JRuby reads from the @components do NOT have volatile semantics, and on TruffleRuby they do
+    # BUT just as an implementation detail, see https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#volatility and
+    # https://github.com/DataDog/dd-trace-rb/pull/1329#issuecomment-776750377 .
+    # Concurrency is hard.
+    COMPONENTS_READ_LOCK = Mutex.new
+    private_constant :COMPONENTS_READ_LOCK
+
     attr_writer :configuration
 
     def configuration
@@ -16,16 +43,20 @@ module Datadog
     end
 
     def configure(target = configuration, opts = {})
+      ruby_version_deprecation_warning
+
       if target.is_a?(Settings)
         yield(target) if block_given?
 
-        # Build immutable components from settings
-        @components ||= nil
-        @components = if @components
-                        replace_components!(target, @components)
-                      else
-                        build_components(target)
-                      end
+        safely_synchronize do |write_components|
+          write_components.call(
+            if components?
+              replace_components!(target, @components)
+            else
+              build_components(target)
+            end
+          )
+        end
 
         target
       else
@@ -36,22 +67,19 @@ module Datadog
     def_delegators \
       :components,
       :health_metrics,
+      :profiler,
       :runtime_metrics,
       :tracer
 
     def logger
-      if instance_variable_defined?(:@components) && @components
+      # avoid initializing components if they didn't already exist
+      current_components = components(allow_initialization: false)
+
+      if current_components
         @temp_logger = nil
-        components.logger
+        current_components.logger
       else
-        # Use default logger without initializing components.
-        # This prevents recursive loops while initializing.
-        # e.g. Get logger --> Build components --> Log message --> Repeat...
-        @temp_logger ||= begin
-          logger = configuration.logger.instance || Datadog::Logger.new(STDOUT)
-          logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
-          logger
-        end
+        logger_without_components
       end
     end
 
@@ -65,26 +93,64 @@ module Datadog
     #
     # Components won't be automatically reinitialized after a shutdown.
     def shutdown!
-      components.shutdown! if instance_variable_defined?(:@components) && @components
+      safely_synchronize do
+        @components.shutdown! if components?
+      end
     end
 
+    protected
+
+    def components(allow_initialization: true)
+      current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
+      return current_components if current_components || !allow_initialization
+
+      safely_synchronize do |write_components|
+        (defined?(@components) && @components) || write_components.call(build_components(configuration))
+      end
+    end
+
+    private
+
     # Gracefully shuts down the tracer and disposes of component references,
     # allowing execution to start anew.
     #
     # In contrast with +#shutdown!+, components will be automatically
     # reinitialized after a reset.
+    #
+    # Used internally to ensure a clean environment between test runs.
     def reset!
-      shutdown!
-      @components = nil
+      safely_synchronize do |write_components|
+        @components.shutdown! if components?
+        write_components.call(nil)
+        configuration.reset!
+      end
     end
 
-    protected
+    def safely_synchronize
+      # Writes to @components should only happen through this proc. Because this proc is only accessible to callers of
+      # safely_synchronize, this forces all writers to go through this method.
+      write_components = proc do |new_value|
+        COMPONENTS_READ_LOCK.synchronize { @components = new_value }
+      end
 
-    def components
-      @components ||= build_components(configuration)
+      COMPONENTS_WRITE_LOCK.synchronize do
+        begin
+          yield write_components
+        rescue ThreadError => e
+          logger_without_components.error(
+            'Detected deadlock during ddtrace initialization. ' \
+            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
+            "\n\tSource:\n\t#{e.backtrace.join("\n\t")}"
+          )
+          nil
+        end
+      end
     end
 
-    private
+    def components?
+      # This does not need to grab the COMPONENTS_READ_LOCK because it's not returning the components
+      (defined?(@components) && @components) != nil
+    end
 
     def build_components(settings)
       components = Components.new(settings)
@@ -99,5 +165,34 @@ module Datadog
       components.startup!(settings)
       components
     end
+
+    def logger_without_components
+      # Use default logger without initializing components.
+      # This enables logging during initialization, otherwise we'd run into deadlocks.
+      @temp_logger ||= begin
+        logger = configuration.logger.instance || Datadog::Logger.new($stdout)
+        logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
+        logger
+      end
+    end
+
+    # Perform version check only once
+    DEPRECATED_RUBY_VERSION = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1')
+    private_constant :DEPRECATED_RUBY_VERSION
+
+    RUBY_VERSION_DEPRECATION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    private_constant :RUBY_VERSION_DEPRECATION_ONLY_ONCE
+
+    def ruby_version_deprecation_warning
+      return unless DEPRECATED_RUBY_VERSION
+
+      RUBY_VERSION_DEPRECATION_ONLY_ONCE.run do
+        Datadog.logger.warn(
+          "Support for Ruby versions < 2.1 in dd-trace-rb is DEPRECATED.\n" \
+          "Last version to support Ruby < 2.1 will be 0.49.x, which will only receive critical bugfixes.\n" \
+          'Support for Ruby versions < 2.1 will be REMOVED in version 0.50.0.'
+        )
+      end
+    end
   end
 end