ddtrace 0.50.0 → 0.51.1

data/lib/ddtrace/configuration/base.rb

@@ -1,4 +1,4 @@
-require 'ddtrace/environment'
+require 'datadog/core/environment/variable_helpers'
 require 'ddtrace/configuration/options'
 
 module Datadog
@@ -6,8 +6,8 @@ module Datadog
     # Basic configuration behavior
     module Base
       def self.included(base)
-        base.extend(Datadog::Environment::Helpers)
-        base.include(Datadog::Environment::Helpers)
+        base.extend(Datadog::Core::Environment::VariableHelpers)
+        base.include(Datadog::Core::Environment::VariableHelpers)
         base.include(Options)
 
         base.extend(ClassMethods)

data/lib/ddtrace/configuration/components.rb

@@ -19,7 +19,7 @@ module Datadog
           options = { enabled: settings.enabled }
           options[:statsd] = settings.statsd unless settings.statsd.nil?
 
-          Datadog::Diagnostics::Health::Metrics.new(options)
+          Datadog::Diagnostics::Health::Metrics.new(**options)
         end
 
         def build_logger(settings)
@@ -34,7 +34,7 @@ module Datadog
           options[:statsd] = settings.runtime_metrics.statsd unless settings.runtime_metrics.statsd.nil?
           options[:services] = [settings.service] unless settings.service.nil?
 
-          Datadog::Runtime::Metrics.new(options)
+          Datadog::Runtime::Metrics.new(**options)
         end
 
         def build_runtime_metrics_worker(settings)
@@ -73,6 +73,35 @@ module Datadog
         def build_profiler(settings, agent_settings)
           return unless Datadog::Profiling.supported? && settings.profiling.enabled
 
+          unless defined?(Datadog::Profiling::Tasks::Setup)
+            # In #1545 a user reported a NameError due to this constant being uninitialized
+            # I've documented my suspicion on why that happened in
+            # https://github.com/DataDog/dd-trace-rb/issues/1545#issuecomment-856049025
+            #
+            # > Thanks for the info! It seems to feed into my theory: there's two moments in the code where we check if
+            # > profiler is "supported": 1) when loading ddtrace (inside preload) and 2) when starting the profile
+            # > after Datadog.configure gets run.
+            # > The problem is that the code assumes that both checks 1) and 2) will always reach the same conclusion:
+            # > either profiler is supported, or profiler is not supported.
+            # > In the problematic case, it looks like in your case check 1 decides that profiler is not
+            # > supported => doesn't load it, and then check 2 decides that it is => assumes it is loaded and tries to
+            # > start it.
+            #
+            # I was never able to validate if this was the issue or why exactly .supported? would change its mind BUT
+            # just in case it happens again, I've left this check which avoids breaking the user's application AND
+            # would instead direct them to report it to us instead, so that we can investigate what's wrong.
+            #
+            # TODO: As of June 2021, most checks in .supported? are related to the google-protobuf gem; so it's
+            # very likely that it was the origin of the issue we saw. Thus, if, as planned we end up moving away from
+            # protobuf OR enough time has passed and no users saw the issue again, we can remove this check altogether.
+            Datadog.logger.error(
+              'Profiling was marked as supported and enabled, but setup task was not loaded properly. ' \
+              'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug'
+            )
+
+            return
+          end
+
           # Load extensions needed to support some of the Profiling features
           Datadog::Profiling::Tasks::Setup.new.run
 
@@ -90,8 +119,8 @@ module Datadog
 
         def build_tracer_tags(settings)
           settings.tags.dup.tap do |tags|
-            tags['env'] = settings.env unless settings.env.nil?
-            tags['version'] = settings.version unless settings.version.nil?
+            tags[Ext::Environment::TAG_ENV] = settings.env unless settings.env.nil?
+            tags[Ext::Environment::TAG_VERSION] = settings.version unless settings.version.nil?
           end
         end
 

data/lib/ddtrace/configuration/settings.rb

@@ -3,8 +3,8 @@ require 'ddtrace/configuration/base'
 
 require 'ddtrace/ext/analytics'
 require 'ddtrace/ext/distributed'
+require 'ddtrace/ext/environment'
 require 'ddtrace/ext/profiling'
-require 'ddtrace/ext/runtime'
 require 'ddtrace/ext/sampling'
 require 'ddtrace/ext/test'
 
@@ -226,8 +226,16 @@ module Datadog
 
       option :service do |o|
         # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, nil) }
+        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, Ext::Environment::FALLBACK_SERVICE_NAME) }
         o.lazy
+
+        # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
+        # nil instead so that one can do
+        # nice_service_name = Datadog.configure.service_without_fallback || nice_service_name_default
+        o.helper(:service_without_fallback) do
+          service_name = service
+          service_name unless service_name.equal?(Ext::Environment::FALLBACK_SERVICE_NAME)
+        end
       end
 
       option :site do |o|
@@ -264,7 +272,7 @@ module Datadog
             self.version = string_tags[Ext::Environment::TAG_VERSION]
           end
 
-          if service.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
+          if service_without_fallback.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
             self.service = string_tags[Ext::Environment::TAG_SERVICE]
           end
 

data/lib/ddtrace/contrib/active_record/utils.rb

@@ -1,4 +1,4 @@
-require 'ddtrace/ext/runtime'
+require 'datadog/core/environment/ext'
 
 module Datadog
   module Contrib
@@ -54,7 +54,7 @@ module Datadog
 
         # DEV: JRuby responds to {ObjectSpace._id2ref}, despite raising an error
         # DEV: when invoked. Thus, we have to explicitly check for Ruby runtime.
-        if Datadog::Ext::Runtime::RUBY_ENGINE != 'jruby'
+        if Datadog::Core::Environment::Ext::RUBY_ENGINE != 'jruby'
           # CRuby has access to {ObjectSpace._id2ref}, which allows for
           # direct look up of the connection object.
           def self.connection_from_id(connection_id)

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

@@ -23,7 +23,7 @@ module Datadog
 
           # Special handling for S3 URL Presigning.
           # @see {Datadog::Contrib::Aws::S3Presigner}
-          ::Aws::S3::Presigner.prepend S3Presigner
+          ::Aws::S3::Presigner.prepend(S3Presigner) if defined?(::Aws::S3::Presigner)
         end
 
         def add_plugin(*targets)

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

@@ -0,0 +1,18 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/lograge/ext'
+
+module Datadog
+  module Contrib
+    module Lograge
+      module Configuration
+        # Custom settings for the Lograge 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/lograge/ext.rb

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

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

@@ -0,0 +1,38 @@
+module Datadog
+  module Contrib
+    module Lograge
+      # Instrumentation for Lograge
+      module Instrumentation
+        def self.included(base)
+          base.prepend(InstanceMethods)
+        end
+
+        # Instance methods for configuration
+        module InstanceMethods
+          def custom_options(event)
+            original_custom_options = super(event)
+
+            # 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']
+            }
+
+            datadog_trace_log_hash.merge(original_custom_options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/lograge/configuration/settings'
+require 'ddtrace/contrib/lograge/patcher'
+
+module Datadog
+  module Contrib
+    module Lograge
+      # Description of Lograge integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('0.11.0')
+
+        register_as :lograge
+
+        def self.version
+          Gem.loaded_specs['lograge'] && Gem.loaded_specs['lograge'].version
+        end
+
+        def self.loaded?
+          !defined?(::Lograge::LogSubscribers::Base).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        # enabled by rails integration and has a hard dependancy on rails
+        # so can safely say this shouldn't ever be part of auto instrumentation
+        # https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lograge.gemspec#L18-L20
+        def auto_instrument?
+          false
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -4,7 +4,7 @@ require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/rack/ext'
 require 'ddtrace/contrib/rack/request_queue'
-require 'ddtrace/environment'
+require 'datadog/core/environment/variable_helpers'
 require 'date'
 
 module Datadog

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

@@ -7,6 +7,8 @@ require 'ddtrace/contrib/action_cable/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/grape/endpoint'
+require 'ddtrace/contrib/lograge/integration'
+require 'ddtrace/contrib/semantic_logger/integration'
 
 require 'ddtrace/contrib/rails/ext'
 require 'ddtrace/contrib/rails/utils'
@@ -46,6 +48,8 @@ module Datadog
             activate_action_pack!(datadog_config, rails_config)
             activate_action_view!(datadog_config, rails_config)
             activate_active_record!(datadog_config, rails_config)
+            activate_lograge!(datadog_config, rails_config)
+            activate_semantic_logger!(datadog_config, rails_config)
           end
         end
 
@@ -53,7 +57,7 @@ module Datadog
           # We set defaults here instead of in the patcher because we need to wait
           # for the Rails application to be fully initialized.
           datadog_config[:rails].tap do |config|
-            config[:service_name] ||= (Datadog.configuration.service || Utils.app_name)
+            config[:service_name] ||= (Datadog.configure.service_without_fallback || Utils.app_name)
             config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
             config[:controller_service] ||= config[:service_name]
             config[:cache_service] ||= "#{config[:service_name]}-cache"
@@ -118,6 +122,26 @@ module Datadog
             service_name: rails_config[:database_service]
           )
         end
+
+        def self.activate_lograge!(datadog_config, rails_config)
+          return unless defined?(::Lograge)
+
+          if rails_config[:log_injection]
+            datadog_config.use(
+              :lograge
+            )
+          end
+        end
+
+        def self.activate_semantic_logger!(datadog_config, rails_config)
+          return unless defined?(::SemanticLogger)
+
+          if rails_config[:log_injection]
+            datadog_config.use(
+              :semantic_logger
+            )
+          end
+        end
       end
     end
   end

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

@@ -6,46 +6,6 @@ module Datadog
       module LogInjection
         module_function
 
-        def add_lograge_logger(app)
-          # custom_options defaults to nil and can be either a hash or a lambda which returns a hash
-          # https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge.rb#L28
-          if (custom_options = app.config.lograge.custom_options).nil?
-            # if it's not set, we set to a lambda that returns DD tracing context
-            app.config.lograge.custom_options = lambda do |_event|
-              # Retrieves trace information for current thread
-              correlation = Datadog.tracer.active_correlation
-
-              datadog_trace_log_hash(correlation)
-            end
-          # check if lambda, if so then define a new lambda which invokes the original lambda and
-          # merges the returned hash with the the DD tracing context hash.
-          elsif custom_options.respond_to?(:call)
-            app.config.lograge.custom_options = lambda do |event|
-              # invoke original lambda
-              result = custom_options.call(event)
-              # Retrieves trace information for current thread
-              correlation = Datadog.tracer.active_correlation
-              # merge original lambda with datadog context
-              result.merge(datadog_trace_log_hash(correlation))
-            end
-          # otherwise if it's just a static hash, we have to wrap that hash in a lambda to retrieve
-          # the DD tracing context, then merge the tracing context with the original static hash.
-          # don't modify if custom_options is not an accepted format.
-          elsif custom_options.is_a?(Hash)
-            app.config.lograge.custom_options = lambda do |_event|
-              # Retrieves trace information for current thread
-              correlation = Datadog.tracer.active_correlation
-
-              # merge original lambda with datadog context
-              custom_options.merge(datadog_trace_log_hash(correlation))
-            end
-          end
-        rescue StandardError => e
-          # TODO: can we use Datadog.logger at this point?
-          Datadog.logger.warn("Unable to add Datadog Trace context to Lograge: #{e.message}")
-          false
-        end
-
         def add_as_tagged_logging_logger(app)
           # we want to check if the current logger is a tagger logger instance
           # log_tags defaults to nil so we have to set as an array if nothing exists yet

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

@@ -3,6 +3,7 @@ require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
 require 'ddtrace/contrib/rails/log_injection'
 require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/contrib/semantic_logger/patcher'
 require 'ddtrace/utils/only_once'
 
 module Datadog
@@ -60,15 +61,16 @@ module Datadog
           should_warn = true
           # check if lograge key exists
           # Note: Rails executes initializers sequentially based on alphabetical order,
-          # and lograge config could occur after dd config.
-          # Checking for `app.config.lograge.enabled` may yield a false negative.
-          # Instead we should naively add custom options if `config.lograge` exists from the lograge Railtie,
-          # since the custom options get ignored without lograge explicitly being enabled.
-          # See: https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge/railtie.rb#L7-L12
-          if app.config.respond_to?(:lograge)
-            Datadog::Contrib::Rails::LogInjection.add_lograge_logger(app)
-            should_warn = false
-          end
+          # and lograge config could occur after datadog config.
+          # So checking for `app.config.lograge.enabled` may yield a false negative,
+          # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
+          # is inconsistent since a lograge initializer would override it.
+          # Instead, we patch Lograge `custom_options` internals directly
+          # as part of Rails framework patching
+          # and just flag off the warning log here.
+          # SemanticLogger we similarly patch in the after_initiaize block, and should flag
+          # off the warning log here if we know we'll patch this gem later.
+          should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
 
           # if lograge isn't set, check if tagged logged is enabled.
           # if so, add proc that injects trace identifiers for tagged logging.

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