ddtrace 1.12.1 → 1.23.2

data/lib/datadog/core/configuration.rb

@@ -81,18 +81,23 @@ module Datadog
         configuration = self.configuration
         yield(configuration)
 
-        safely_synchronize do |write_components|
+        built_components = false
+
+        components = safely_synchronize do |write_components|
           write_components.call(
             if components?
               replace_components!(configuration, @components)
             else
               components = build_components(configuration)
-              components.telemetry.started!
+              built_components = true
               components
             end
           )
         end
 
+        # Should only be called the first time components are built
+        components.telemetry.started! if built_components
+
         configuration
       end
 
@@ -192,9 +197,20 @@ module Datadog
         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))
+        built_components = false
+
+        components = safely_synchronize do |write_components|
+          if defined?(@components) && @components
+            @components
+          else
+            built_components = true
+            write_components.call(build_components(configuration))
+          end
         end
+
+        # Should only be called the first time components are built
+        components.telemetry.started! if built_components && components && components.telemetry
+        components
       end
 
       private
@@ -273,6 +289,10 @@ module Datadog
       def handle_interrupt_shutdown!
         logger = Datadog.logger
         shutdown_thread = Thread.new { shutdown! }
+        unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          shutdown_thread.name = Datadog::Core::Configuration.name
+        end
+
         print_message_treshold_seconds = 0.2
 
         slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?

data/lib/datadog/core/diagnostics/environment_logger.rb

@@ -1,284 +1,181 @@
-require 'date'
+# frozen_string_literal: true
+
 require 'json'
 require 'rbconfig'
+require 'time'
 
 module Datadog
   module Core
     module Diagnostics
-      # A holistic collection of the environment in which ddtrace is running.
-      # This logger should allow for easy reporting by users to Datadog support.
-      #
-      module EnvironmentLogger
-        class << self
-          # Outputs environment information to {Datadog.logger}.
-          # Executes only once for the lifetime of the program.
-          def log!(transport_responses)
-            return if (defined?(@executed) && @executed) || !log?
-
-            @executed = true
-
-            data = EnvironmentCollector.new.collect!(transport_responses)
-            data.reject! { |_, v| v.nil? } # Remove empty values from hash output
-
-            log_environment!(data.to_json)
-            log_error!('Agent Error'.freeze, data[:agent_error]) if data[:agent_error]
-          rescue => e
-            Datadog.logger.warn("Failed to collect environment information: #{e} Location: #{Array(e.backtrace).first}")
-          end
-
-          private
-
-          def log_environment!(line)
-            Datadog.logger.info("DATADOG CONFIGURATION - #{line}")
-          end
-
-          def log_error!(type, error)
-            Datadog.logger.warn("DATADOG DIAGNOSTIC - #{type}: #{error}")
-          end
-
-          # Are we logging the environment data?
-          def log?
-            startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
-            if startup_logs_enabled.nil?
-              !repl? # Suppress logs if we running in a REPL
-            else
-              startup_logs_enabled
-            end
-          end
-
-          REPL_PROGRAM_NAMES = %w[irb pry].freeze
-
-          def repl?
-            REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
-          end
-        end
-      end
-
-      # Collects environment information for diagnostic logging
-      class EnvironmentCollector
-        # @return [String] current time in ISO8601 format
-        def date
-          DateTime.now.iso8601
-        end
-
-        # Best portable guess of OS information.
-        # @return [String] platform string
-        def os_name
-          RbConfig::CONFIG['host'.freeze]
+      # Base class for EnvironmentLoggers - should allow for easy reporting by users to Datadog support.
+      module EnvironmentLogging
+        def log_configuration!(prefix, data)
+          logger.info("DATADOG CONFIGURATION - #{prefix} - #{data}")
         end
 
-        # @return [String] ddtrace version
-        def version
-          DDTrace::VERSION::STRING
+        def log_error!(prefix, type, error)
+          logger.warn("DATADOG ERROR - #{prefix} - #{type}: #{error}")
         end
 
-        # @return [String] "ruby"
-        def lang
-          Core::Environment::Ext::LANG
-        end
+        protected
 
-        # Supported Ruby language version.
-        # Will be distinct from VM version for non-MRI environments.
-        # @return [String]
-        def lang_version
-          Core::Environment::Ext::LANG_VERSION
+        def logger
+          Datadog.logger
         end
 
-        # @return [String] configured application environment
-        def env
-          Datadog.configuration.env
-        end
+        # If logger should log and hasn't logged already, then output environment configuration and possible errors.
+        def log_once!
+          # Check if already been executed
+          return false if (defined?(@executed) && @executed) || !log?
 
-        # @return [Boolean, nil]
-        def enabled
-          Datadog.configuration.tracing.enabled
-        end
+          yield if block_given?
 
-        # @return [String] configured application service name
-        def service
-          Datadog.configuration.service
+          @executed = true
         end
 
-        # @return [String] configured application version
-        def dd_version
-          Datadog.configuration.version
-        end
-
-        # @return [String, nil] target agent URL for trace flushing
-        def agent_url
-          # Retrieve the effect agent URL, regardless of how it was configured
-          transport = Tracing.send(:tracer).writer.transport
-
-          # return `nil` with IO transport
-          return unless transport.respond_to?(:client)
-
-          adapter = transport.client.api.adapter
-          adapter.url
+        # Are we logging the environment data?
+        def log?
+          startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
+          if startup_logs_enabled.nil?
+            !repl? && !rspec? # Suppress logs if we are running in a REPL or rspec
+          else
+            startup_logs_enabled
+          end
         end
 
-        # Error returned by Datadog agent during a tracer flush attempt
-        # @return [String] concatenated list of transport errors
-        def agent_error(transport_responses)
-          error_responses = transport_responses.reject(&:ok?)
+        REPL_PROGRAM_NAMES = %w[irb pry].freeze
 
-          return nil if error_responses.empty?
-
-          error_responses.map(&:inspect).join(','.freeze)
-        end
-
-        # @return [Boolean, nil] debug mode enabled in configuration
-        def debug
-          !!Datadog.configuration.diagnostics.debug
+        def repl?
+          REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
         end
 
-        # @return [Boolean, nil] analytics enabled in configuration
-        def analytics_enabled
-          !!Datadog.configuration.tracing.analytics.enabled
+        def rspec?
+          $PROGRAM_NAME.end_with?('rspec')
         end
+      end
 
-        # @return [Numeric, nil] tracer sample rate configured
-        def sample_rate
-          sampler = Datadog.configuration.tracing.sampler
-          return nil unless sampler
+      # Collects and logs Core diagnostic information
+      module EnvironmentLogger
+        extend EnvironmentLogging
 
-          sampler.sample_rate(nil) rescue nil
+        def self.collect_and_log!(extra_fields = nil)
+          log_once! do
+            data = EnvironmentCollector.collect_config!
+            data = data.merge(extra_fields) if extra_fields
+            log_configuration!('CORE', data.to_json)
+          end
+        rescue => e
+          logger.warn("Failed to collect core environment information: #{e} Location: #{Array(e.backtrace).first}")
         end
+      end
 
-        # DEV: We currently only support SimpleRule instances.
-        # DEV: These are the most commonly used rules.
-        # DEV: We should expand support for other rules in the future,
-        # DEV: although it is tricky to serialize arbitrary rules.
-        #
-        # @return [Hash, nil] sample rules configured
-        def sampling_rules
-          sampler = Datadog.configuration.tracing.sampler
-          return nil unless sampler.is_a?(Tracing::Sampling::PrioritySampler) &&
-            sampler.priority_sampler.is_a?(Tracing::Sampling::RuleSampler)
-
-          sampler.priority_sampler.rules.map do |rule|
-            next unless rule.is_a?(Tracing::Sampling::SimpleRule)
-
+      # Collects environment information for Core diagnostic logging
+      module EnvironmentCollector
+        class << self
+          def collect_config!
             {
-              name: rule.matcher.name,
-              service: rule.matcher.service,
-              sample_rate: rule.sampler.sample_rate(nil)
+              date: date,
+              os_name: os_name,
+              version: version,
+              lang: lang,
+              lang_version: lang_version,
+              env: env,
+              service: service,
+              dd_version: dd_version,
+              debug: debug,
+              tags: tags,
+              runtime_metrics_enabled: runtime_metrics_enabled,
+              vm: vm,
+              health_metrics_enabled: health_metrics_enabled
             }
-          end.compact
-        end
-
-        # @return [Hash, nil] concatenated list of global tracer tags configured
-        def tags
-          tags = Datadog.configuration.tags
-          return nil if tags.empty?
+          end
 
-          hash_serializer(tags)
-        end
+          # @return [String] current time in ISO8601 format
+          def date
+            Time.now.utc.iso8601
+          end
 
-        # @return [Boolean, nil] runtime metrics enabled in configuration
-        def runtime_metrics_enabled
-          Datadog.configuration.runtime_metrics.enabled
-        end
+          # Best portable guess of OS information.
+          # @return [String] platform string
+          def os_name
+            RbConfig::CONFIG['host']
+          end
 
-        # Concatenated list of integrations activated, with their gem version.
-        # Example: "rails@6.0.3,rack@2.2.3"
-        #
-        # @return [String, nil]
-        def integrations_loaded
-          integrations = instrumented_integrations
-          return if integrations.empty?
+          # @return [String] ddtrace version
+          def version
+            DDTrace::VERSION::STRING
+          end
 
-          integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(','.freeze)
-        end
+          # @return [String] "ruby"
+          def lang
+            Core::Environment::Ext::LANG
+          end
 
-        # Ruby VM name and version.
-        # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
-        # @return [String, nil]
-        def vm
-          # RUBY_ENGINE_VERSION returns the VM version, which
-          # will differ from RUBY_VERSION for non-mri VMs.
-          if defined?(RUBY_ENGINE_VERSION)
-            "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
-          else
-            # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
-            "#{RUBY_ENGINE}-#{RUBY_VERSION}"
+          # Supported Ruby language version.
+          # Will be distinct from VM version for non-MRI environments.
+          # @return [String]
+          def lang_version
+            Core::Environment::Ext::LANG_VERSION
           end
-        end
 
-        # @return [Boolean, nil] partial flushing enabled in configuration
-        def partial_flushing_enabled
-          !!Datadog.configuration.tracing.partial_flush.enabled
-        end
+          # @return [String] configured application environment
+          def env
+            Datadog.configuration.env
+          end
 
-        # @return [Boolean, nil] priority sampling enabled in configuration
-        def priority_sampling_enabled
-          !!Datadog.configuration.tracing.priority_sampling
-        end
+          # @return [String] configured application service name
+          def service
+            Datadog.configuration.service
+          end
 
-        # @return [Boolean, nil] health metrics enabled in configuration
-        def health_metrics_enabled
-          !!Datadog.configuration.diagnostics.health_metrics.enabled
-        end
+          # @return [String] configured application version
+          def dd_version
+            Datadog.configuration.version
+          end
 
-        def profiling_enabled
-          !!Datadog.configuration.profiling.enabled
-        end
+          # @return [Boolean, nil] debug mode enabled in configuration
+          def debug
+            !!Datadog.configuration.diagnostics.debug
+          end
 
-        # TODO: Populate when automatic log correlation is implemented
-        # def logs_correlation_enabled
-        # end
+          # @return [Hash, nil] concatenated list of global tracer tags configured
+          def tags
+            tags = Datadog.configuration.tags
+            return nil if tags.empty?
 
-        # @return [Hash] environment information available at call time
-        def collect!(transport_responses)
-          {
-            date: date,
-            os_name: os_name,
-            version: version,
-            lang: lang,
-            lang_version: lang_version,
-            env: env,
-            enabled: enabled,
-            service: service,
-            dd_version: dd_version,
-            agent_url: agent_url,
-            agent_error: agent_error(transport_responses),
-            debug: debug,
-            analytics_enabled: analytics_enabled,
-            sample_rate: sample_rate,
-            sampling_rules: sampling_rules,
-            tags: tags,
-            runtime_metrics_enabled: runtime_metrics_enabled,
-            integrations_loaded: integrations_loaded,
-            vm: vm,
-            partial_flushing_enabled: partial_flushing_enabled,
-            priority_sampling_enabled: priority_sampling_enabled,
-            health_metrics_enabled: health_metrics_enabled,
-            profiling_enabled: profiling_enabled,
-            **instrumented_integrations_settings
-          }
-        end
+            hash_serializer(tags)
+          end
 
-        private
+          # @return [Boolean, nil] runtime metrics enabled in configuration
+          def runtime_metrics_enabled
+            Datadog.configuration.runtime_metrics.enabled
+          end
 
-        def instrumented_integrations
-          Datadog.configuration.tracing.instrumented_integrations
-        end
+          # Ruby VM name and version.
+          # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
+          # @return [String, nil]
+          def vm
+            # RUBY_ENGINE_VERSION returns the VM version, which
+            # will differ from RUBY_VERSION for non-mri VMs.
+            if defined?(RUBY_ENGINE_VERSION)
+              "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
+            else
+              # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
+              "#{RUBY_ENGINE}-#{RUBY_VERSION}"
+            end
+          end
 
-        # Capture all active integration settings into "integrationName_settingName: value" entries.
-        def instrumented_integrations_settings
-          instrumented_integrations.flat_map do |name, integration|
-            integration.configuration.to_h.flat_map do |setting, value|
-              next [] if setting == :tracer # Skip internal Ruby objects
+          # @return [Boolean, nil] health metrics enabled in configuration
+          def health_metrics_enabled
+            !!Datadog.configuration.diagnostics.health_metrics.enabled
+          end
 
-              # Convert value to a string to avoid custom #to_json
-              # handlers possibly causing errors.
-              [[:"integration_#{name}_#{setting}", value.to_s]]
-            end
-          end.to_h
-        end
+          private
 
-        # Outputs "k1:v1,k2:v2,..."
-        def hash_serializer(h)
-          h.map { |k, v| "#{k}:#{v}" }.join(','.freeze)
+          # Outputs "k1:v1,k2:v2,..."
+          def hash_serializer(h)
+            h.map { |k, v| "#{k}:#{v}" }.join(',')
+          end
         end
       end
     end

data/lib/datadog/core/environment/class_count.rb

@@ -5,15 +5,15 @@ module Datadog
     module Environment
       # Retrieves number of classes from runtime
       module ClassCount
-        module_function
-
-        def value
+        def self.value
           ::ObjectSpace.count_objects[:T_CLASS]
         end
 
-        def available?
-          ::ObjectSpace.respond_to?(:count_objects) \
-           && ::ObjectSpace.count_objects.key?(:T_CLASS)
+        def self.available?
+          return @class_count_available if defined?(@class_count_available)
+
+          @class_count_available =
+            ::ObjectSpace.respond_to?(:count_objects) && ::ObjectSpace.count_objects.key?(:T_CLASS)
         end
       end
     end

data/lib/datadog/core/environment/execution.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Datadog
+  module Core
+    module Environment
+      # Provides information about the execution environment on the current process.
+      module Execution
+        class << self
+          # Is this process running in a development environment?
+          # This can be used to make decisions about when to enable
+          # background systems like worker threads or telemetry.
+          def development?
+            !!(webmock_enabled? || repl? || test? || rails_development?)
+          end
+
+          # WebMock stores the reference to `Net::HTTP` with constant `OriginalNetHTTP`, and when WebMock enables,
+          # the adapter swaps `Net::HTTP` reference to its mock object, @webMockNetHTTP.
+          #
+          # Hence, we can detect by
+          #   1. Checking if `Net::HTTP` is referring to mock object
+          #   => ::Net::HTTP.equal?(::WebMock::HttpLibAdapters::NetHttpAdapter.instance_variable_get(:@webMockNetHTTP))
+          #
+          #   2. Checking if `Net::HTTP` is referring to the original one
+          #   => ::Net::HTTP.equal?(::WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP)
+          def webmock_enabled?
+            defined?(::WebMock::HttpLibAdapters::NetHttpAdapter) &&
+              defined?(::Net::HTTP) &&
+              ::Net::HTTP.equal?(::WebMock::HttpLibAdapters::NetHttpAdapter.instance_variable_get(:@webMockNetHTTP))
+          end
+
+          private
+
+          # Is this process running a test?
+          def test?
+            rspec? || minitest? || cucumber?
+          end
+
+          # Is this process running inside on a Read–eval–print loop?
+          # DEV: REPLs always set the program name to the exact REPL name.
+          def repl?
+            REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
+          end
+
+          REPL_PROGRAM_NAMES = %w[irb pry].freeze
+          private_constant :REPL_PROGRAM_NAMES
+
+          # RSpec always runs using the `rspec` file https://github.com/rspec/rspec-core/blob/main/exe/rspec
+          def rspec?
+            $PROGRAM_NAME.end_with?(RSPEC_PROGRAM_NAME)
+          end
+
+          RSPEC_PROGRAM_NAME = '/rspec'
+          private_constant :RSPEC_PROGRAM_NAME
+
+          # Check if Minitest is present and installed to run.
+          def minitest?
+            # Minitest >= 5
+            (defined?(::Minitest) &&
+              ::Minitest.class_variable_defined?(:@@installed_at_exit) &&
+              ::Minitest.class_variable_get(:@@installed_at_exit)) ||
+              # Minitest < 5
+              (defined?(::Minitest::Unit) &&
+                ::Minitest::Unit.class_variable_defined?(:@@installed_at_exit) &&
+                ::Minitest::Unit.class_variable_get(:@@installed_at_exit))
+          end
+
+          # Check if we are running from `bin/cucumber` or `cucumber/rake/task`.
+          def cucumber?
+            defined?(::Cucumber::Cli)
+          end
+
+          # If this is a Rails application, use different heuristics to detect
+          # whether this is a development environment or not.
+          def rails_development?
+            # A Rails Spring Ruby process is a bit peculiar: the process is agnostic
+            # whether the application is running as a console or server.
+            # Luckily, the Spring gem *must not* be installed in a production environment so
+            # detecting its presence is enough to deduct if this is a development environment.
+            #
+            # @see https://github.com/rails/spring/blob/48b299348ace2188444489a0c216a6f3e9687281/README.md?plain=1#L204-L207
+            defined?(::Spring) || rails_env_development?
+          end
+
+          RAILS_ENV_DEVELOPMENT = Set['development', 'test'].freeze
+          private_constant :RAILS_ENV_DEVELOPMENT
+
+          # By default, every Rails application has three environments: `development`, `test`, and `production`.
+          # This has been the case since Rails 3.0.0:
+          # https://github.com/rails/rails/blob/3e48484ff16ea07ffe5db232bf43c14992e273c1/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt#L144
+          #
+          # Instead of checking for "not production", we instead check for "development" and "test" because
+          # it's common to have a custom "staging" environment, and such environment normally want to run as close
+          # to production as possible.
+          def rails_env_development?
+            defined?(::Rails.env) && RAILS_ENV_DEVELOPMENT.include?(::Rails.env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/environment/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../ddtrace/version'
 
 module Datadog
@@ -13,12 +15,12 @@ module Datadog
                            RUBY_VERSION
                          end
 
-        ENV_API_KEY = 'DD_API_KEY'.freeze
-        ENV_ENVIRONMENT = 'DD_ENV'.freeze
-        ENV_SERVICE = 'DD_SERVICE'.freeze
-        ENV_SITE = 'DD_SITE'.freeze
-        ENV_TAGS = 'DD_TAGS'.freeze
-        ENV_VERSION = 'DD_VERSION'.freeze
+        ENV_API_KEY = 'DD_API_KEY'
+        ENV_ENVIRONMENT = 'DD_ENV'
+        ENV_SERVICE = 'DD_SERVICE'
+        ENV_SITE = 'DD_SITE'
+        ENV_TAGS = 'DD_TAGS'
+        ENV_VERSION = 'DD_VERSION'
         FALLBACK_SERVICE_NAME =
           begin
             File.basename($PROGRAM_NAME, '.*')
@@ -26,15 +28,15 @@ module Datadog
             'ruby'
           end.freeze
 
-        LANG = 'ruby'.freeze
+        LANG = 'ruby'
         LANG_ENGINE = RUBY_ENGINE
-        LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}".freeze
+        LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}"
         LANG_PLATFORM = RUBY_PLATFORM
         LANG_VERSION = RUBY_VERSION
         RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
-        TAG_ENV = 'env'.freeze
-        TAG_SERVICE = 'service'.freeze
-        TAG_VERSION = 'version'.freeze
+        TAG_ENV = 'env'
+        TAG_SERVICE = 'service'
+        TAG_VERSION = 'version'
 
         # TODO: Migrate to Datadog::Tracing
         TRACER_VERSION = DDTrace::VERSION::STRING

data/lib/datadog/core/environment/git.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../git/ext'
+require_relative '../utils/url'
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves git repository information from environment variables
+      module Git
+        def self.git_repository_url
+          return @git_repository_url if defined?(@git_repository_url)
+
+          @git_repository_url = Utils::Url.filter_basic_auth(ENV[Datadog::Core::Git::Ext::ENV_REPOSITORY_URL])
+        end
+
+        def self.git_commit_sha
+          return @git_commit_sha if defined?(@git_commit_sha)
+
+          @git_commit_sha = ENV[Datadog::Core::Git::Ext::ENV_COMMIT_SHA]
+        end
+      end
+    end
+  end
+end