ddtrace 0.46.0 → 0.51.0

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

@@ -25,7 +25,7 @@ module Datadog
 
         def self.compatible?
           super \
-            && version >= Gem::Version.new('1.0') \
+            && version >= MINIMUM_VERSION \
             && version < MAXIMUM_VERSION
         end
 

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

@@ -17,11 +17,11 @@ module Datadog
 
         def patch
           require_relative 'resque_job'
-          get_option(:workers).each { |worker| worker.extend(ResqueJob) }
-        end
 
-        def get_option(option)
-          Datadog.configuration[:resque].get_option(option)
+          ::Resque::Job.prepend(Resque::Job)
+
+          workers = Datadog.configuration[:resque][:workers] || []
+          workers.each { |worker| worker.extend(ResqueJob) }
         end
       end
     end

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -7,9 +7,30 @@ require 'resque'
 module Datadog
   module Contrib
     module Resque
+      # Automatically configures jobs with {ResqueJob} plugin.
+      module Job
+        def perform
+          if Datadog.configuration[:resque][:workers].nil?
+            job = payload_class
+            job.extend(Datadog::Contrib::Resque::ResqueJob) unless job.is_a? Datadog::Contrib::Resque::ResqueJob
+          end
+        ensure
+          super
+        end
+      end
+
       # Uses Resque job hooks to create traces
       module ResqueJob
-        def around_perform(*args)
+        # `around_perform` hooks are executed in alphabetical order.
+        # we use the lowest printable character that allows for an inline
+        # method definition ('0'), alongside our naming prefix for identification.
+        #
+        # We could, in theory, use any character (e.g "\x00"), but this will lead
+        # to unreadable stack traces that contain this method call.
+        #
+        # We could also just use `around_perform` but this might override the user's
+        # own method.
+        def around_perform0_ddtrace(*args)
           return yield unless datadog_configuration && tracer
 
           tracer.trace(Ext::SPAN_JOB, span_options) do |span|

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

@@ -15,7 +15,7 @@ module Datadog
           require 'ddtrace/ext/app_types'
           require 'ddtrace/contrib/rest_client/request_patch'
 
-          ::RestClient::Request.send(:include, RequestPatch)
+          ::RestClient::Request.include(RequestPatch)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Datadog
       # RestClient RequestPatch
       module RequestPatch
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # InstanceMethods - implementing instrumentation

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

@@ -0,0 +1,18 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/semantic_logger/ext'
+
+module Datadog
+  module Contrib
+    module SemanticLogger
+      module Configuration
+        # Custom settings for the SemanticLogger integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Datadog
+  module Contrib
+    module SemanticLogger
+      # SemanticLogger integration constants
+      module Ext
+        ENV_ENABLED = 'DD_TRACE_SEMANTIC_LOGGER_ENABLED'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Datadog
+  module Contrib
+    module SemanticLogger
+      # Instrumentation for SemanticLogger
+      module Instrumentation
+        def self.included(base)
+          base.prepend(InstanceMethods)
+        end
+
+        # Instance methods for configuration
+        module InstanceMethods
+          def log(log, message = nil, progname = nil, &block)
+            original_named_tags = log.named_tags || {}
+
+            # Retrieves trace information for current thread
+            correlation = Datadog.tracer.active_correlation
+            # merge original lambda with datadog context
+
+            datadog_trace_log_hash = {
+              # Adds IDs as tags to log output
+              dd: {
+                # To preserve precision during JSON serialization, use strings for large numbers
+                trace_id: correlation.trace_id.to_s,
+                span_id: correlation.span_id.to_s,
+                env: correlation.env.to_s,
+                service: correlation.service.to_s,
+                version: correlation.version.to_s
+              },
+              ddsource: ['ruby']
+            }
+
+            # # if the user already has conflicting log_tags
+            # # we want them to clobber ours, because we should allow them to override
+            # # if needed.
+            log.named_tags = datadog_trace_log_hash.merge(original_named_tags)
+            super(log, message, progname, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/semantic_logger/configuration/settings'
+require 'ddtrace/contrib/semantic_logger/patcher'
+
+module Datadog
+  module Contrib
+    module SemanticLogger
+      # Description of SemanticLogger integration
+      class Integration
+        include Contrib::Integration
+
+        # v4 had a migration to `named_tags` instead of `payload`
+        # and has been out for almost 5 years at this point
+        # it's probably reasonable to nudge users to using modern ruby libs
+        MINIMUM_VERSION = Gem::Version.new('4.0.0')
+
+        register_as :semantic_logger
+
+        def self.version
+          Gem.loaded_specs['semantic_logger'] && Gem.loaded_specs['semantic_logger'].version
+        end
+
+        def self.loaded?
+          !defined?(::SemanticLogger::Logger).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        # TODO: abstract out the log injection related instrumentation into it's own module so we dont
+        # keep having to do these workarounds
+        def auto_instrument?
+          false
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/semantic_logger/instrumentation'
+
+module Datadog
+  module Contrib
+    # Datadog SemanticLogger integration.
+    module SemanticLogger
+      # Patcher enables patching of 'semantic_logger' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        # patch applies our patch
+        def patch
+          ::SemanticLogger::Logger.include(Instrumentation)
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Datadog
       # Adds instrumentation to Sequel::Database
       module Database
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # Instance methods for instrumenting Sequel::Database

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

@@ -10,7 +10,7 @@ module Datadog
       # Adds instrumentation to Sequel::Dataset
       module Dataset
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # Instance methods for instrumenting Sequel::Dataset

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

@@ -21,11 +21,11 @@ module Datadog
         end
 
         def patch_sequel_database
-          ::Sequel::Database.send(:include, Database)
+          ::Sequel::Database.include(Database)
         end
 
         def patch_sequel_dataset
-          ::Sequel::Dataset.send(:include, Dataset)
+          ::Sequel::Dataset.include(Dataset)
         end
       end
     end

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

@@ -23,6 +23,7 @@ module Datadog
 
           option :service_name, default: Ext::SERVICE_NAME
           option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
+          option :tag_body, default: false
         end
       end
     end

data/lib/ddtrace/contrib/shoryuken/tracer.rb

@@ -12,8 +12,12 @@ module Datadog
         end
 
         def call(worker_instance, queue, sqs_msg, body)
-          @tracer.trace(Ext::SPAN_JOB, service: @shoryuken_service, span_type: Datadog::Ext::AppTypes::WORKER,
-                                       on_error: @error_handler) do |span|
+          @tracer.trace(
+            Ext::SPAN_JOB,
+            service: @shoryuken_service,
+            span_type: Datadog::Ext::AppTypes::WORKER,
+            on_error: @error_handler
+          ) do |span|
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
@@ -26,7 +30,7 @@ module Datadog
             span.set_tag(Ext::TAG_JOB_ID, sqs_msg.message_id)
             span.set_tag(Ext::TAG_JOB_QUEUE, queue)
             span.set_tag(Ext::TAG_JOB_ATTRIBUTES, sqs_msg.attributes) if sqs_msg.respond_to?(:attributes)
-            span.set_tag(Ext::TAG_JOB_BODY, body)
+            span.set_tag(Ext::TAG_JOB_BODY, body) if configuration[:tag_body]
 
             yield
           end

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

@@ -20,7 +20,7 @@ module Datadog
 
         def register_tracer
           ::Sinatra.send(:register, Datadog::Contrib::Sinatra::Tracer)
-          ::Sinatra::Base.send(:prepend, Sinatra::Tracer::Base)
+          ::Sinatra::Base.prepend(Sinatra::Tracer::Base)
         end
       end
     end

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

@@ -10,13 +10,11 @@ module Datadog
         module_function
 
         def patch!
-          ::SuckerPunch.class_eval do
-            class << self
-              alias_method :__exception_handler, :exception_handler
+          ::SuckerPunch.singleton_class.class_eval do
+            alias_method :__exception_handler, :exception_handler
 
-              def exception_handler
-                ::Datadog::Contrib::SuckerPunch::ExceptionHandler::METHOD
-              end
+            def exception_handler
+              ::Datadog::Contrib::SuckerPunch::ExceptionHandler::METHOD
             end
           end
         end

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

@@ -10,6 +10,7 @@ module Datadog
         module_function
 
         # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
         def patch!
           # rubocop:disable Metrics/BlockLength
           ::SuckerPunch::Job::ClassMethods.class_eval do
@@ -34,6 +35,7 @@ module Datadog
             rescue => e
               ::SuckerPunch.__exception_handler.call(e, self, args)
             end
+            ruby2_keywords :__run_perform if respond_to?(:ruby2_keywords, true)
 
             alias_method :__perform_async, :perform_async
             def perform_async(*args)
@@ -46,6 +48,7 @@ module Datadog
                 __perform_async(*args)
               end
             end
+            ruby2_keywords :perform_async if respond_to?(:ruby2_keywords, true)
 
             alias_method :__perform_in, :perform_in
             def perform_in(interval, *args)
@@ -59,6 +62,7 @@ module Datadog
                 __perform_in(interval, *args)
               end
             end
+            ruby2_keywords :perform_in if respond_to?(:ruby2_keywords, true)
 
             private
 

data/lib/ddtrace/correlation.rb

@@ -1,5 +1,5 @@
 require 'ddtrace/ext/correlation'
-require 'ddtrace/environment'
+require 'datadog/core/environment/variable_helpers'
 
 module Datadog
   # Contains behavior for managing correlations with tracing

data/lib/ddtrace/diagnostics/environment_logger.rb

@@ -12,7 +12,7 @@ module Datadog
         # Outputs environment information to {Datadog.logger}.
         # Executes only for the lifetime of the program.
         def log!(transport_responses)
-          return if @executed || !log?
+          return if (defined?(@executed) && @executed) || !log?
 
           @executed = true
 
@@ -73,14 +73,14 @@ module Datadog
 
       # @return [String] "ruby"
       def lang
-        Ext::Runtime::LANG
+        Core::Environment::Ext::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
+        Core::Environment::Ext::LANG_VERSION
       end
 
       # @return [String] configured application environment
@@ -259,7 +259,7 @@ module Datadog
 
       # Capture all active integration settings into "integrationName_settingName: value" entries.
       def instrumented_integrations_settings
-        Hash[instrumented_integrations.flat_map do |name, integration|
+        instrumented_integrations.flat_map do |name, integration|
           integration.configuration.to_h.flat_map do |setting, value|
             next [] if setting == :tracer # Skip internal Ruby objects
 
@@ -267,7 +267,7 @@ module Datadog
             # handlers possibly causing errors.
             [[:"integration_#{name}_#{setting}", value.to_s]]
           end
-        end]
+        end.to_h
       end
 
       # Outputs "k1:v1,k2:v2,..."

data/lib/ddtrace/error.rb

@@ -1,21 +1,90 @@
+# frozen_string_literal: true
+
 # Datadog global namespace
 module Datadog
   # Error is a value-object responsible for sanitizing/encapsulating error data
   class Error
     attr_reader :type, :message, :backtrace
 
-    def self.build_from(value)
-      case value
-      when Error then value
-      when Array then new(*value)
-      when Exception then new(value.class, value.message, value.backtrace)
-      when ContainsMessage then new(value.class, value.message)
-      else BlankError
+    class << self
+      def build_from(value)
+        case value
+        when Error then value
+        when Array then new(*value)
+        when Exception then new(value.class, value.message, full_backtrace(value))
+        when ContainsMessage then new(value.class, value.message)
+        else BlankError
+        end
+      end
+
+      private
+
+      # Returns a stack trace with nested error causes and details.
+      #
+      # This manually implements Ruby >= 2.6 error output for two reasons:
+      #
+      # 1. It is not available in Ruby < 2.6.
+      # 2. It's measurably faster to manually implement it in Ruby.
+      #
+      # This method mimics the exact output of
+      # `ex.full_message(highlight: false, order: :top)`
+      # but it's around 3x faster in our benchmark test
+      # at `error_spec.rb`.
+      def full_backtrace(ex)
+        backtrace = String.new
+        backtrace_for(ex, backtrace)
+
+        # Avoid circular causes
+        causes = {}
+        causes[ex] = true
+
+        cause = ex
+        while (cause = cause.cause) && !causes.key?(cause)
+          backtrace_for(cause, backtrace)
+          causes[cause] = true
+        end
+
+        backtrace
+      end
+
+      # Outputs the following format for exceptions:
+      #
+      # ```
+      # error_spec.rb:55:in `wrapper': wrapper layer (RuntimeError)
+      # 	from error_spec.rb:40:in `wrapper'
+      # 	from error_spec.rb:61:in `caller'
+      #   ...
+      # ```
+      def backtrace_for(ex, backtrace)
+        trace = ex.backtrace
+        return unless trace
+
+        if trace[0]
+          # Add Exception information to error line
+          backtrace << trace[0]
+          backtrace << ': '
+          backtrace << ex.message.to_s
+          backtrace << ' ('
+          backtrace << ex.class.to_s
+          backtrace << ')'
+        end
+
+        if trace[1]
+          # Ident stack trace for caller lines, to separate
+          # them from the main error lines.
+          trace[1..-1].each do |line|
+            backtrace << "\n\tfrom "
+            backtrace << line
+          end
+        end
+
+        backtrace << "\n"
       end
     end
 
     def initialize(type = nil, message = nil, backtrace = nil)
-      backtrace = Array(backtrace).join("\n")
+      backtrace = Array(backtrace).join("\n") unless backtrace.is_a?(String)
+
       @type = Utils.utf8_encode(type)
       @message = Utils.utf8_encode(message)
       @backtrace = Utils.utf8_encode(backtrace)