ddtrace 0.50.0 → 0.51.1

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/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

@@ -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

data/lib/ddtrace/ext/environment.rb

@@ -8,6 +8,13 @@ module Datadog
       ENV_TAGS = 'DD_TAGS'.freeze
       ENV_VERSION = 'DD_VERSION'.freeze
 
+      FALLBACK_SERVICE_NAME =
+        begin
+          File.basename($PROGRAM_NAME, '.*')
+        rescue StandardError
+          'ruby'
+        end.freeze
+
       TAG_ENV = 'env'.freeze
       TAG_SERVICE = 'service'.freeze
       TAG_VERSION = 'version'.freeze

data/lib/ddtrace/ext/git.rb

@@ -3,9 +3,17 @@ module Datadog
     # Defines constants for Git tags
     module Git
       TAG_BRANCH = 'git.branch'.freeze
-      TAG_COMMIT_SHA = 'git.commit.sha'.freeze
       TAG_REPOSITORY_URL = 'git.repository_url'.freeze
       TAG_TAG = 'git.tag'.freeze
+
+      TAG_COMMIT_AUTHOR_DATE = 'git.commit.author.date'.freeze
+      TAG_COMMIT_AUTHOR_EMAIL = 'git.commit.author.email'.freeze
+      TAG_COMMIT_AUTHOR_NAME = 'git.commit.author.name'.freeze
+      TAG_COMMIT_COMMITTER_DATE = 'git.commit.committer.date'.freeze
+      TAG_COMMIT_COMMITTER_EMAIL = 'git.commit.committer.email'.freeze
+      TAG_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'.freeze
+      TAG_COMMIT_MESSAGE = 'git.commit.message'.freeze
+      TAG_COMMIT_SHA = 'git.commit.sha'.freeze
     end
   end
 end

data/lib/ddtrace/ext/runtime.rb

@@ -3,15 +3,6 @@ require 'ddtrace/version'
 module Datadog
   module Ext
     module Runtime
-      # Identity
-      LANG = 'ruby'.freeze
-      LANG_ENGINE = RUBY_ENGINE
-      LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}".freeze
-      LANG_PLATFORM = RUBY_PLATFORM
-      LANG_VERSION = RUBY_VERSION
-      RUBY_ENGINE =  ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
-      TRACER_VERSION = Datadog::VERSION::STRING
-
       TAG_ID = 'runtime-id'.freeze
       TAG_LANG = 'language'.freeze
 

data/lib/ddtrace/metrics.rb

@@ -2,8 +2,8 @@ require 'ddtrace/ext/metrics'
 
 require 'set'
 require 'logger'
-require 'ddtrace/environment'
-require 'ddtrace/runtime/identity'
+require 'datadog/core/environment/identity'
+require 'ddtrace/ext/environment'
 require 'ddtrace/utils/only_once'
 require 'ddtrace/utils/time'
 
@@ -13,22 +13,24 @@ module Datadog
   class Metrics
     attr_reader :statsd
 
-    def initialize(options = {})
-      @statsd = options.fetch(:statsd) { default_statsd_client if supported? }
-      @enabled = options.fetch(:enabled, true)
+    def initialize(statsd: nil, enabled: true, **_)
+      @statsd =
+        if supported?
+          statsd || default_statsd_client
+        else
+          ignored_statsd_warning if statsd
+          nil
+        end
+      @enabled = enabled
     end
 
     def supported?
-      version = (
-          defined?(Datadog::Statsd::VERSION) &&
-          Datadog::Statsd::VERSION &&
-          Gem::Version.new(Datadog::Statsd::VERSION)
-        ) || (
-          Gem.loaded_specs['dogstatsd-ruby'] &&
-          Gem.loaded_specs['dogstatsd-ruby'].version
-        )
+      version = dogstatsd_version
 
-      !version.nil? && (version >= Gem::Version.new('3.3.0'))
+      !version.nil? && version >= Gem::Version.new('3.3.0') &&
+        # dogstatsd-ruby >= 5.0 & < 5.2.0 has known issues with process forks
+        # and do not support the single thread mode we use to avoid this problem.
+        !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.2'))
     end
 
     def enabled?
@@ -50,10 +52,23 @@ module Datadog
     def default_statsd_client
       require 'datadog/statsd'
 
-      incompatible_statsd_warning
-
       # Create a StatsD client that points to the agent.
-      Datadog::Statsd.new(default_hostname, default_port)
+      #
+      # We use `single_thread: true`, as dogstatsd-ruby >= 5.0 creates a background thread
+      # by default, but does not handle forks correctly, causing resource leaks.
+      #
+      # Using dogstatsd-ruby >= 5.0 is still valuable, as it supports
+      # transparent batch metric submission, which reduces submission
+      # overhead.
+      #
+      # Versions < 5.0 are always single-threaded, but do not have the kwarg option.
+      options = if dogstatsd_version >= Gem::Version.new('5.2')
+                  { single_thread: true }
+                else
+                  {}
+                end
+
+      Datadog::Statsd.new(default_hostname, default_port, **options)
     end
 
     def configure(options = {})
@@ -144,10 +159,10 @@ module Datadog
     module Options
       DEFAULT = {
         tags: DEFAULT_TAGS = [
-          "#{Ext::Metrics::TAG_LANG}:#{Runtime::Identity.lang}".freeze,
-          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Runtime::Identity.lang_interpreter}".freeze,
-          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Runtime::Identity.lang_version}".freeze,
-          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Runtime::Identity.tracer_version}".freeze
+          "#{Ext::Metrics::TAG_LANG}:#{Core::Environment::Identity.lang}".freeze,
+          "#{Ext::Metrics::TAG_LANG_INTERPRETER}:#{Core::Environment::Identity.lang_interpreter}".freeze,
+          "#{Ext::Metrics::TAG_LANG_VERSION}:#{Core::Environment::Identity.lang_version}".freeze,
+          "#{Ext::Metrics::TAG_TRACER_VERSION}:#{Core::Environment::Identity.tracer_version}".freeze
         ].freeze
       }.freeze
 
@@ -238,16 +253,27 @@ module Datadog
 
     private
 
-    INCOMPATIBLE_STATSD_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :INCOMPATIBLE_STATSD_ONLY_ONCE
+    def dogstatsd_version
+      return @dogstatsd_version if instance_variable_defined?(:@dogstatsd_version)
+
+      @dogstatsd_version = (
+        defined?(Datadog::Statsd::VERSION) &&
+          Datadog::Statsd::VERSION &&
+          Gem::Version.new(Datadog::Statsd::VERSION)
+      ) || (
+        Gem.loaded_specs['dogstatsd-ruby'] &&
+          Gem.loaded_specs['dogstatsd-ruby'].version
+      )
+    end
 
-    def incompatible_statsd_warning
-      return if Gem.loaded_specs['dogstatsd-ruby'].version < Gem::Version.new('5.0')
+    IGNORED_STATSD_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    private_constant :IGNORED_STATSD_ONLY_ONCE
 
-      INCOMPATIBLE_STATSD_ONLY_ONCE.run do
+    def ignored_statsd_warning
+      IGNORED_STATSD_ONLY_ONCE.run do
         Datadog.logger.warn(
-          'This version of `ddtrace` is incompatible with `dogstastd-ruby` version >= 5.0 and can ' \
-          'cause unbounded memory usage. Please use `dogstastd-ruby` version < 5.0 instead.'
+          'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
+          "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.2'` on your Gemfile or gems.rb file."
         )
       end
     end

data/lib/ddtrace/profiling/ext/cpu.rb

@@ -43,9 +43,24 @@ module Datadog
           elsif Gem::Specification.find_all_by_name('rollbar', ROLLBAR_INCOMPATIBLE_VERSIONS).any?
             'You have an incompatible rollbar gem version installed; ensure that you have rollbar >= 3.1.2 by ' \
             "adding `gem 'rollbar', '>= 3.1.2'` to your Gemfile or gems.rb file. " \
-            'See https://github.com/rollbar/rollbar-gem/pull/1018 for details.'
+            'See https://github.com/rollbar/rollbar-gem/pull/1018 for details'
+          elsif Gem::Specification.find_all_by_name('logging').any? && logging_inherit_context_enabled?
+            'The `logging` gem is installed and its thread inherit context feature is enabled. ' \
+            "Please add LOGGING_INHERIT_CONTEXT=false to your application's environment variables to disable the " \
+            'conflicting `logging` gem feature. ' \
+            'See https://github.com/TwP/logging/pull/230 for details'
           end
         end
+
+        private_class_method def self.logging_inherit_context_enabled?
+          # The logging gem provides a mechanism to disable the conflicting behavior, see
+          # https://github.com/TwP/logging/blob/ae9872d093833b2a5a34cbe1faa4e895a81f6845/lib/logging/diagnostic_context.rb#L418
+          # Here we check if the behavior is enabled
+          inherit_context_configuration = ENV['LOGGING_INHERIT_CONTEXT']
+
+          inherit_context_configuration.nil? ||
+          (inherit_context_configuration && !%w[false no 0].include?(inherit_context_configuration.downcase))
+        end
       end
     end
   end

data/lib/ddtrace/profiling/flush.rb

@@ -1,5 +1,5 @@
-require 'ddtrace/runtime/identity'
-require 'ddtrace/runtime/socket'
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/socket'
 
 module Datadog
   module Profiling
@@ -23,16 +23,16 @@ module Datadog
     ) do
       def initialize(*args)
         super
-        self.runtime_id = runtime_id || Datadog::Runtime::Identity.id
+        self.runtime_id = runtime_id || Datadog::Core::Environment::Identity.id
         self.service = service || Datadog.configuration.service
         self.env = env || Datadog.configuration.env
         self.version = version || Datadog.configuration.version
-        self.host = host || Datadog::Runtime::Socket.hostname
-        self.language = language || Datadog::Runtime::Identity.lang
-        self.runtime_engine = runtime_engine || Datadog::Runtime::Identity.lang_engine
-        self.runtime_platform = runtime_platform || Datadog::Runtime::Identity.lang_platform
-        self.runtime_version = runtime_version || Datadog::Runtime::Identity.lang_version
-        self.profiler_version = profiler_version || Datadog::Runtime::Identity.tracer_version
+        self.host = host || Datadog::Core::Environment::Socket.hostname
+        self.language = language || Datadog::Core::Environment::Identity.lang
+        self.runtime_engine = runtime_engine || Datadog::Core::Environment::Identity.lang_engine
+        self.runtime_platform = runtime_platform || Datadog::Core::Environment::Identity.lang_platform
+        self.runtime_version = runtime_version || Datadog::Core::Environment::Identity.lang_version
+        self.profiler_version = profiler_version || Datadog::Core::Environment::Identity.tracer_version
         self.tags = tags || Datadog.configuration.tags
       end
     end

data/lib/ddtrace/profiling/transport/http.rb

@@ -1,7 +1,7 @@
-require 'ddtrace/ext/runtime'
+require 'datadog/core/environment/ext'
 require 'ddtrace/ext/transport'
 
-require 'ddtrace/runtime/container'
+require 'datadog/core/environment/container'
 
 require 'ddtrace/profiling/transport/http/builder'
 require 'ddtrace/profiling/transport/http/api'
@@ -55,13 +55,13 @@ module Datadog
 
         def default_headers
           {
-            Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Datadog::Ext::Runtime::LANG,
-            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Datadog::Ext::Runtime::LANG_VERSION,
-            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Ext::Runtime::LANG_INTERPRETER,
-            Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Datadog::Ext::Runtime::TRACER_VERSION
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
+            Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Core::Environment::Ext::TRACER_VERSION
           }.tap do |headers|
             # Add container ID, if present.
-            container_id = Datadog::Runtime::Container.container_id
+            container_id = Datadog::Core::Environment::Container.container_id
             headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
           end
         end

data/lib/ddtrace/runtime/metrics.rb

@@ -2,16 +2,16 @@ require 'ddtrace/ext/integration'
 require 'ddtrace/ext/runtime'
 
 require 'ddtrace/metrics'
-require 'ddtrace/runtime/class_count'
-require 'ddtrace/runtime/gc'
-require 'ddtrace/runtime/identity'
-require 'ddtrace/runtime/thread_count'
+require 'datadog/core/environment/class_count'
+require 'datadog/core/environment/gc'
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/thread_count'
 
 module Datadog
   module Runtime
     # For generating runtime metrics
     class Metrics < Datadog::Metrics
-      def initialize(options = {})
+      def initialize(**options)
         super
 
         # Initialize service list
@@ -29,7 +29,7 @@ module Datadog
         # Tag span with language and runtime ID for association with metrics.
         # We only tag spans that performed internal application work.
         unless span.get_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE)
-          span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
+          span.set_tag(Ext::Runtime::TAG_LANG, Core::Environment::Identity.lang)
         end
       end
 
@@ -52,13 +52,21 @@ module Datadog
       def flush
         return unless enabled?
 
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, ClassCount.value) if ClassCount.available? }
-        try_flush { gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, ThreadCount.value) if ThreadCount.available? }
-        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if GC.available? }
+        try_flush do
+          if Core::Environment::ClassCount.available?
+            gauge(Ext::Runtime::Metrics::METRIC_CLASS_COUNT, Core::Environment::ClassCount.value)
+          end
+        end
+        try_flush do
+          if Core::Environment::ThreadCount.available?
+            gauge(Ext::Runtime::Metrics::METRIC_THREAD_COUNT, Core::Environment::ThreadCount.value)
+          end
+        end
+        try_flush { gc_metrics.each { |metric, value| gauge(metric, value) } if Core::Environment::GC.available? }
       end
 
       def gc_metrics
-        GC.stat.flat_map do |k, v|
+        Core::Environment::GC.stat.flat_map do |k, v|
           nested_gc_metric(Ext::Runtime::Metrics::METRIC_GC_PREFIX, k, v)
         end.to_h
       end