ddtrace 0.35.0 → 0.38.0

data/lib/ddtrace/contrib/mongodb/instrumentation.rb

@@ -49,14 +49,13 @@ module Datadog
           module InstanceMethods
             def datadog_pin
               @datadog_pin ||= begin
-                tracer = Datadog.configuration[:mongo][:tracer]
                 service = Datadog.configuration[:mongo][:service_name]
 
                 Datadog::Pin.new(
                   service,
                   app: Datadog::Contrib::MongoDB::Ext::APP,
                   app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: tracer
+                  tracer: -> { Datadog.configuration[:mongo][:tracer] }
                 )
               end
             end

data/lib/ddtrace/contrib/mysql2/instrumentation.rb

@@ -36,7 +36,7 @@ module Datadog
               Datadog.configuration[:mysql2][:service_name],
               app: Ext::APP,
               app_type: Datadog::Ext::AppTypes::DB,
-              tracer: Datadog.configuration[:mysql2][:tracer]
+              tracer: -> { Datadog.configuration[:mysql2][:tracer] }
             )
           end
 

data/lib/ddtrace/contrib/patcher.rb

@@ -31,18 +31,24 @@ module Datadog
                 Datadog.health_metrics.instrumentation_patched(1, tags: default_tags)
               end
             rescue StandardError => e
-              # Log the error
-              Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
-
-              # Emit a metric
-              tags = default_tags
-              tags << "error:#{e.class.name}"
-
-              Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
+              on_patch_error(e)
             end
           end
         end
 
+        # Processes patching errors. This default implementation logs the error and reports relevant metrics.
+        # @param e [Exception]
+        def on_patch_error(e)
+          # Log the error
+          Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
+
+          # Emit a metric
+          tags = default_tags
+          tags << "error:#{e.class.name}"
+
+          Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
+        end
+
         private
 
         def default_tags

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -98,23 +98,26 @@ module Datadog
           request_span.set_error(e) unless request_span.nil?
           raise e
         ensure
-          # Rack is a really low level interface and it doesn't provide any
-          # advanced functionality like routers. Because of that, we assume that
-          # the underlying framework or application has more knowledge about
-          # the result for this request; `resource` and `tags` are expected to
-          # be set in another level but if they're missing, reasonable defaults
-          # are used.
-          set_request_tags!(request_span, env, status, headers, response, original_env)
-
-          # ensure the request_span is finished and the context reset;
-          # this assumes that the Rack middleware creates a root span
-          request_span.finish
+          if request_span
+            # Rack is a really low level interface and it doesn't provide any
+            # advanced functionality like routers. Because of that, we assume that
+            # the underlying framework or application has more knowledge about
+            # the result for this request; `resource` and `tags` are expected to
+            # be set in another level but if they're missing, reasonable defaults
+            # are used.
+            set_request_tags!(request_span, env, status, headers, response, original_env || env)
+
+            # ensure the request_span is finished and the context reset;
+            # this assumes that the Rack middleware creates a root span
+            request_span.finish
+          end
+
           frontend_span.finish unless frontend_span.nil?
 
           # TODO: Remove this once we change how context propagation works. This
           # ensures we clean thread-local variables on each HTTP request avoiding
           # memory leaks.
-          tracer.provider.context = Datadog::Context.new
+          tracer.provider.context = Datadog::Context.new if tracer
         end
 
         def resource_name_for(env, status)

data/lib/ddtrace/contrib/rails/configuration/settings.rb

@@ -6,6 +6,19 @@ module Datadog
       module Configuration
         # Custom settings for the Rails integration
         class Settings < Contrib::Configuration::Settings
+          def initialize(options = {})
+            super(options)
+
+            # NOTE: Eager load these
+            #       Rails integration is responsible for orchestrating other integrations.
+            #       When using environment variables, settings will not be automatically
+            #       filled because nothing explicitly calls them. They must though, so
+            #       integrations like ActionPack can receive the value as it should.
+            #       Trigger these manually to force an eager load and propagate them.
+            analytics_enabled
+            analytics_sample_rate
+          end
+
           option :analytics_enabled do |o|
             o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
             o.lazy
@@ -63,17 +76,6 @@ module Datadog
               Datadog.configuration[:action_view][:template_base_path] = value
             end
           end
-
-          option :tracer do |o|
-            o.delegate_to { Datadog.tracer }
-            o.on_set do |value|
-              Datadog.configuration[:action_cable][:tracer] = value
-              Datadog.configuration[:active_record][:tracer] = value
-              Datadog.configuration[:active_support][:tracer] = value
-              Datadog.configuration[:action_pack][:tracer] = value
-              Datadog.configuration[:action_view][:tracer] = value
-            end
-          end
         end
       end
     end

data/lib/ddtrace/contrib/rails/framework.rb

@@ -19,32 +19,40 @@ module Datadog
       # - handle configuration entries which are specific to Datadog tracing
       # - instrument parts of the framework when needed
       module Framework
-        # configure Datadog settings
+        # After the Rails application finishes initializing, we configure the Rails
+        # integration and all its sub-components with the application information
+        # available.
+        # We do this after the initialization because not all the information we
+        # require is available before then.
         def self.setup
-          config = config_with_defaults
-
-          activate_rack!(config)
-          activate_action_cable!(config)
-          activate_active_support!(config)
-          activate_action_pack!(config)
-          activate_action_view!(config)
-          activate_active_record!(config)
-
-          # By default, default service would be guessed from the script
-          # being executed, but here we know better, get it from Rails config.
-          # Don't set this if service has been explicitly provided by the user.
-          Datadog.configuration.service ||= config[:service_name]
-
-          # Update the tracer if its not the default tracer.
-          if config[:tracer] != Datadog.configuration.tracer
-            config[:tracer].default_service = config[:service_name]
+          # NOTE: #configure has the side effect of rebuilding trace components.
+          #       During a typical Rails application lifecycle, we will see trace
+          #       components initialized twice because of this. This is necessary
+          #       because key configuration is not available until after the Rails
+          #       application has fully loaded, and some of this configuration is
+          #       used to reconfigure tracer components with Rails-sourced defaults.
+          #       This is a trade-off we take to get nice defaults.
+          Datadog.configure do |datadog_config|
+            rails_config = config_with_defaults(datadog_config)
+
+            # By default, default service would be guessed from the script
+            # being executed, but here we know better, get it from Rails config.
+            # Don't set this if service has been explicitly provided by the user.
+            datadog_config.service ||= rails_config[:service_name]
+
+            activate_rack!(datadog_config, rails_config)
+            activate_action_cable!(datadog_config, rails_config)
+            activate_active_support!(datadog_config, rails_config)
+            activate_action_pack!(datadog_config, rails_config)
+            activate_action_view!(datadog_config, rails_config)
+            activate_active_record!(datadog_config, rails_config)
           end
         end
 
-        def self.config_with_defaults
+        def self.config_with_defaults(datadog_config)
           # We set defaults here instead of in the patcher because we need to wait
           # for the Rails application to be fully initialized.
-          Datadog.configuration[:rails].tap do |config|
+          datadog_config[:rails].tap do |config|
             config[:service_name] ||= (Datadog.configuration.service || Utils.app_name)
             config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
             config[:controller_service] ||= config[:service_name]
@@ -52,64 +60,62 @@ module Datadog
           end
         end
 
-        def self.activate_rack!(config)
-          Datadog.configuration.use(
+        def self.activate_rack!(datadog_config, rails_config)
+          datadog_config.use(
             :rack,
-            tracer: config[:tracer],
             application: ::Rails.application,
-            service_name: config[:service_name],
-            middleware_names: config[:middleware_names],
-            distributed_tracing: config[:distributed_tracing]
+            service_name: rails_config[:service_name],
+            middleware_names: rails_config[:middleware_names],
+            distributed_tracing: rails_config[:distributed_tracing]
           )
         end
 
-        def self.activate_active_support!(config)
+        def self.activate_active_support!(datadog_config, rails_config)
           return unless defined?(::ActiveSupport)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :active_support,
-            cache_service: config[:cache_service],
-            tracer: config[:tracer]
+            cache_service: rails_config[:cache_service]
           )
         end
 
-        def self.activate_action_cable!(config)
+        def self.activate_action_cable!(datadog_config, rails_config)
           return unless defined?(::ActionCable)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :action_cable,
-            service_name: "#{config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}",
-            tracer: config[:tracer]
+            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}"
           )
         end
 
-        def self.activate_action_pack!(config)
+        def self.activate_action_pack!(datadog_config, rails_config)
           return unless defined?(::ActionPack)
 
-          Datadog.configuration.use(
+          # TODO: This is configuring ActionPack but not patching. It will queue ActionPack
+          #       for patching, but patching won't take place until Datadog.configure completes.
+          #       Should we manually patch here?
+
+          datadog_config.use(
             :action_pack,
-            service_name: config[:service_name],
-            tracer: config[:tracer]
+            service_name: rails_config[:service_name]
           )
         end
 
-        def self.activate_action_view!(config)
+        def self.activate_action_view!(datadog_config, rails_config)
           return unless defined?(::ActionView)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :action_view,
-            service_name: config[:service_name],
-            tracer: config[:tracer]
+            service_name: rails_config[:service_name]
           )
         end
 
-        def self.activate_active_record!(config)
+        def self.activate_active_record!(datadog_config, rails_config)
           return unless defined?(::ActiveRecord)
 
-          Datadog.configuration.use(
+          datadog_config.use(
             :active_record,
-            service_name: config[:database_service],
-            tracer: config[:tracer]
+            service_name: rails_config[:database_service]
           )
         end
       end

data/lib/ddtrace/contrib/rails/integration.rb

@@ -16,7 +16,7 @@ module Datadog
         register_as :rails, auto_patch: false
 
         def self.version
-          Gem.loaded_specs['rails'] && Gem.loaded_specs['rails'].version
+          Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
         end
 
         def self.loaded?

data/lib/ddtrace/contrib/redis/patcher.rb

@@ -76,7 +76,7 @@ module Datadog
                   datadog_configuration[:service_name],
                   app: Ext::APP,
                   app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: datadog_configuration[:tracer]
+                  tracer: -> { datadog_configuration[:tracer] }
                 )
                 pin.onto(self)
               end

data/lib/ddtrace/contrib/rest_client/request_patch.rb

@@ -62,11 +62,11 @@ module Datadog
             # rubocop:disable Lint/RescueException
           rescue Exception => e
             # rubocop:enable Lint/RescueException
-            span.set_error(e)
+            span.set_error(e) if span
 
             raise e
           ensure
-            span.finish
+            span.finish if span
           end
 
           private

data/lib/ddtrace/contrib/sequel/database.rb

@@ -36,7 +36,7 @@ module Datadog
               Datadog.configuration[:sequel][:service_name] || adapter_name,
               app: Ext::APP,
               app_type: Datadog::Ext::AppTypes::DB,
-              tracer: Datadog.configuration[:sequel][:tracer] || Datadog.tracer
+              tracer: -> { Datadog.configuration[:sequel][:tracer] }
             )
           end
 

data/lib/ddtrace/contrib/sidekiq/ext.rb

@@ -15,6 +15,7 @@ module Datadog
         TAG_JOB_ID = 'sidekiq.job.id'.freeze
         TAG_JOB_QUEUE = 'sidekiq.job.queue'.freeze
         TAG_JOB_RETRY = 'sidekiq.job.retry'.freeze
+        TAG_JOB_RETRY_COUNT = 'sidekiq.job.retry_count'.freeze
         TAG_JOB_WRAPPER = 'sidekiq.job.wrapper'.freeze
         TAG_JOB_ARGS = 'sidekiq.job.args'.freeze
       end

data/lib/ddtrace/contrib/sidekiq/patcher.rb

@@ -15,14 +15,21 @@ module Datadog
 
         def patch
           require 'ddtrace/contrib/sidekiq/client_tracer'
+          require 'ddtrace/contrib/sidekiq/server_tracer'
+
           ::Sidekiq.configure_client do |config|
             config.client_middleware do |chain|
               chain.add(Sidekiq::ClientTracer)
             end
           end
 
-          require 'ddtrace/contrib/sidekiq/server_tracer'
           ::Sidekiq.configure_server do |config|
+            # If a job enqueues another job, make sure it has the same client
+            # middleware.
+            config.client_middleware do |chain|
+              chain.add(Sidekiq::ClientTracer)
+            end
+
             config.server_middleware do |chain|
               chain.add(Sidekiq::ServerTracer)
             end

data/lib/ddtrace/contrib/sidekiq/server_tracer.rb

@@ -31,6 +31,7 @@ module Datadog
 
             span.set_tag(Ext::TAG_JOB_ID, job['jid'])
             span.set_tag(Ext::TAG_JOB_RETRY, job['retry'])
+            span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
             span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
             span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
             span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))

data/lib/ddtrace/contrib/sucker_punch/patcher.rb

@@ -29,7 +29,7 @@ module Datadog
             get_option(:service_name),
             app: Ext::APP,
             app_type: Datadog::Ext::AppTypes::WORKER,
-            tracer: get_option(:tracer)
+            tracer: -> { get_option(:tracer) }
           ).onto(::SuckerPunch)
         end
 

data/lib/ddtrace/diagnostics/environment_logger.rb

@@ -0,0 +1,278 @@
+require 'date'
+require 'json'
+require 'rbconfig'
+
+module Datadog
+  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.
+    #
+    # rubocop:disable Style/DoubleNegation
+    module EnvironmentLogger
+      class << self
+        # Outputs environment information to {Datadog.logger}.
+        # Executes only for the lifetime of the program.
+        def log!(transport_responses)
+          return if @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: #{e.backtrace.first}")
+        end
+
+        private
+
+        def log_environment!(line)
+          Datadog.logger.warn("DATADOG TRACER CONFIGURATION - #{line}")
+        end
+
+        def log_error!(type, error)
+          Datadog.logger.warn("DATADOG TRACER 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]
+      end
+
+      # @return [String] ddtrace version
+      def version
+        VERSION::STRING
+      end
+
+      # @return [String] "ruby"
+      def lang
+        Ext::Runtime::LANG
+      end
+
+      # Supported Ruby language version.
+      # Will be distinct from VM version for non-MRI environments.
+      # @return [String]
+      def lang_version
+        Ext::Runtime::LANG_VERSION
+      end
+
+      # @return [String] configured application environment
+      def env
+        Datadog.configuration.env
+      end
+
+      # @return [Boolean, nil]
+      def enabled
+        Datadog.configuration.tracer.enabled
+      end
+
+      # @return [String] configured application service name
+      def service
+        Datadog.configuration.service
+      end
+
+      # @return [String] configured application version
+      def dd_version
+        Datadog.configuration.version
+      end
+
+      # @return [String] target agent URL for trace flushing
+      def agent_url
+        # Retrieve the effect agent URL, regardless of how it was configured
+        transport = Datadog.tracer.writer.transport
+        adapter = transport.client.api.adapter
+        adapter.url
+      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?)
+
+        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
+      end
+
+      # @return [Boolean, nil] analytics enabled in configuration
+      def analytics_enabled
+        !!Datadog.configuration.analytics.enabled
+      end
+
+      # @return [Numeric, nil] tracer sample rate configured
+      def sample_rate
+        sampler = Datadog.configuration.tracer.sampler
+        return nil unless sampler
+
+        sampler.sample_rate(nil) rescue nil
+      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.tracer.sampler
+        return nil unless sampler.is_a?(Datadog::PrioritySampler) &&
+                          sampler.priority_sampler.is_a?(Datadog::Sampling::RuleSampler)
+
+        sampler.priority_sampler.rules.map do |rule|
+          next unless rule.is_a?(Datadog::Sampling::SimpleRule)
+
+          {
+            name: rule.matcher.name,
+            service: rule.matcher.service,
+            sample_rate: rule.sampler.sample_rate(nil)
+          }
+        end.compact
+      end
+
+      # @return [Hash, nil] concatenated list of global tracer tags configured
+      def tags
+        tags = Datadog.configuration.tags
+        return nil if tags.empty?
+        hash_serializer(tags)
+      end
+
+      # @return [Boolean, nil] runtime metrics enabled in configuration
+      def runtime_metrics_enabled
+        Datadog.configuration.runtime_metrics.enabled
+      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?
+
+        integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(','.freeze)
+      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
+
+      # @return [Boolean, nil] partial flushing enabled in configuration
+      def partial_flushing_enabled
+        !!Datadog.configuration.tracer.partial_flush.enabled
+      end
+
+      # @return [Boolean, nil] priority sampling enabled in configuration
+      def priority_sampling_enabled
+        !!Datadog.configuration.tracer.priority_sampling
+      end
+
+      # @return [Boolean, nil] health metrics enabled in configuration
+      def health_metrics_enabled
+        !!Datadog.configuration.diagnostics.health_metrics.enabled
+      end
+
+      # TODO: Populate when profiling is implemented
+      # def profiling_enabled
+      # end
+
+      # TODO: Populate when automatic log correlation is implemented
+      # def logs_correlation_enabled
+      # end
+
+      # @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,
+          **instrumented_integrations_settings
+        }
+      end
+
+      private
+
+      def instrumented_integrations
+        Datadog.configuration.instrumented_integrations
+      end
+
+      # Capture all active integration settings into "integrationName_settingName: value" entries.
+      def instrumented_integrations_settings
+        Hash[instrumented_integrations.flat_map do |name, integration|
+          integration.configuration.to_h.flat_map do |setting, value|
+            next [] if setting == :tracer # Skip internal Ruby objects
+
+            # Convert value to a string to avoid custom #to_json
+            # handlers possibly causing errors.
+            [[:"integration_#{name}_#{setting}", value.to_s]]
+          end
+        end]
+      end
+
+      # Outputs "k1:v1,k2:v2,..."
+      def hash_serializer(h)
+        h.map { |k, v| "#{k}:#{v}" }.join(','.freeze)
+      end
+    end
+  end
+end