ddtrace 0.34.1 → 1.23.1

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

@@ -0,0 +1,89 @@
+require_relative 'cgroup'
+
+module Datadog
+  module Core
+    module Environment
+      # For container environments
+      module Container
+        UUID_PATTERN = '[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}'.freeze
+        CONTAINER_PATTERN = '[0-9a-f]{64}'.freeze
+
+        PLATFORM_REGEX = /(?<platform>.*?)(?:.slice)?$/.freeze
+        POD_REGEX = /(?<pod>(pod)?#{UUID_PATTERN})(?:.slice)?$/.freeze
+        CONTAINER_REGEX = /(?<container>#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/.freeze
+        FARGATE_14_CONTAINER_REGEX = /(?<container>[0-9a-f]{32}-[0-9]{1,10})/.freeze
+
+        Descriptor = Struct.new(
+          :platform,
+          :container_id,
+          :task_uid
+        )
+
+        module_function
+
+        def platform
+          descriptor.platform
+        end
+
+        def container_id
+          descriptor.container_id
+        end
+
+        def task_uid
+          descriptor.task_uid
+        end
+
+        def descriptor
+          @descriptor ||= Descriptor.new.tap do |descriptor|
+            begin
+              Cgroup.descriptors.each do |cgroup_descriptor|
+                # Parse container data from cgroup descriptor
+                path = cgroup_descriptor.path
+                next if path.nil?
+
+                # Split path into parts
+                parts = path.split('/')
+                parts.shift # Remove leading empty part
+
+                # Read info from path
+                next if parts.empty?
+
+                platform = parts[0][PLATFORM_REGEX, :platform]
+                container_id, task_uid = nil
+
+                case parts.length
+                when 0..1
+                  next
+                when 2
+                  container_id = parts[-1][CONTAINER_REGEX, :container] \
+                                || parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
+                else
+                  if (container_id = parts[-1][CONTAINER_REGEX, :container])
+                    task_uid = parts[-2][POD_REGEX, :pod] || parts[1][POD_REGEX, :pod]
+                  else
+                    container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
+                  end
+                end
+
+                # If container ID wasn't found, ignore.
+                # Path might describe a non-container environment.
+                next if container_id.nil?
+
+                descriptor.platform = platform
+                descriptor.container_id = container_id
+                descriptor.task_uid = task_uid
+
+                break
+              end
+            rescue StandardError => e
+              Datadog.logger.error(
+                "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+              )
+            end
+          end
+        end
+      end
+    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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../ddtrace/version'
+
+module Datadog
+  module Core
+    module Environment
+      # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+      module Ext
+        # e.g for CRuby '3.0.1', for JRuby '9.2.19.0', for TruffleRuby '21.1.0'
+        ENGINE_VERSION = if defined?(RUBY_ENGINE_VERSION)
+                           RUBY_ENGINE_VERSION
+                         else
+                           # CRuby < 2.3 doesn't support RUBY_ENGINE_VERSION
+                           RUBY_VERSION
+                         end
+
+        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, '.*')
+          rescue StandardError
+            'ruby'
+          end.freeze
+
+        LANG = 'ruby'
+        LANG_ENGINE = RUBY_ENGINE
+        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'
+        TAG_SERVICE = 'service'
+        TAG_VERSION = 'version'
+
+        # TODO: Migrate to Datadog::Tracing
+        TRACER_VERSION = DDTrace::VERSION::STRING
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves garbage collection statistics
+      module GC
+        module_function
+
+        def stat
+          ::GC.stat
+        end
+
+        def available?
+          defined?(::GC) && ::GC.respond_to?(:stat)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'ext'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      # @public_api
+      module Identity
+        extend Core::Utils::Forking
+
+        module_function
+
+        # Retrieves number of classes from runtime
+        def id
+          @id ||= ::SecureRandom.uuid.freeze
+
+          # Check if runtime has changed, e.g. forked.
+          after_fork! { @id = ::SecureRandom.uuid.freeze }
+
+          @id
+        end
+
+        def pid
+          ::Process.pid
+        end
+
+        def lang
+          Core::Environment::Ext::LANG
+        end
+
+        def lang_engine
+          Core::Environment::Ext::LANG_ENGINE
+        end
+
+        def lang_interpreter
+          Core::Environment::Ext::LANG_INTERPRETER
+        end
+
+        def lang_platform
+          Core::Environment::Ext::LANG_PLATFORM
+        end
+
+        def lang_version
+          Core::Environment::Ext::LANG_VERSION
+        end
+
+        # Returns tracer version, rubygems-style
+        def tracer_version
+          Core::Environment::Ext::TRACER_VERSION
+        end
+
+        # Returns tracer version, comforming to https://semver.org/spec/v2.0.0.html
+        def tracer_version_semver2
+          major, minor, patch, rest = tracer_version.split('.', 4)
+
+          semver = "#{major}.#{minor}.#{patch}"
+
+          return semver unless rest
+
+          pre = ''
+          build = ''
+
+          rest.split('.').tap do |segments|
+            if segments.length >= 4
+              pre   = "-#{segments.shift}"
+              build = "+#{segments.join('.')}"
+            elsif segments.length == 1
+              pre = "-#{segments.shift}"
+            else
+              build = "+#{segments.join('.')}"
+            end
+          end
+
+          semver + pre + build
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'etc'
+
+require_relative 'identity'
+
+module Datadog
+  module Core
+    module Environment
+      # For gathering information about the platform
+      module Platform
+        module_function
+
+        # @return [String] ISA of host; `uname -m`
+        def architecture
+          Identity.lang_version >= '2.2' ? Etc.uname[:machine] : Gem::Platform.local.cpu
+        end
+
+        # @return [String] name of host; `uname -n`
+        def hostname
+          Identity.lang_version >= '2.2' ? Etc.uname[:nodename] : nil
+        end
+
+        # System name, normally `Linux` or `Darwin` (but 'Mac OS X' on JRuby);
+        # @return [String] name of kernel; `uname -s`.
+        def kernel_name
+          Identity.lang_version >= '2.2' ? Etc.uname[:sysname] : Gem::Platform.local.os.capitalize
+        end
+
+        # @return [String] kernel release; `uname -r`
+        def kernel_release
+          if Identity.lang_engine == 'jruby'
+            Etc.uname[:version] # Java's `os.version` maps to `uname -r`
+          elsif Identity.lang_version >= '2.2'
+            Etc.uname[:release]
+          end
+        end
+
+        # @return [String] kernel version; `uname -v`
+        def kernel_version
+          Etc.uname[:version] if Identity.lang_engine != 'jruby' && Identity.lang_version >= '2.2'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'socket'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      module Socket
+        extend Core::Utils::Forking
+
+        module_function
+
+        def hostname
+          # Check if runtime has changed, e.g. forked.
+          after_fork! { @hostname = ::Socket.gethostname.freeze }
+
+          @hostname ||= ::Socket.gethostname.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves number of threads from runtime
+      module ThreadCount
+        module_function
+
+        def value
+          Thread.list.count
+        end
+
+        def available?
+          Thread.respond_to?(:list)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Namespace for handling application environment
+    module Environment
+      # Defines helper methods for environment
+      # @public_api
+      module VariableHelpers
+        extend self
+
+        # Reads an environment variable as a Boolean.
+        #
+        # @param [String] var environment variable
+        # @param [Array<String>] var list of environment variables
+        # @param [Boolean] default the default value if the keys in `var` are not present in the environment
+        # @param [Boolean] deprecation_warning when `var` is a list, record a deprecation log when
+        #   the first key in `var` is not used.
+        # @return [Boolean] if the environment value is the string `true` or `1`
+        # @return [default] if the environment value is not found
+        def env_to_bool(var, default = nil, deprecation_warning: true)
+          var = decode_array(var, deprecation_warning)
+          if var && ENV.key?(var)
+            value = ENV[var].to_s.strip
+            value.downcase!
+            value == 'true' || value == '1' # rubocop:disable Style/MultipleComparison
+          else
+            default
+          end
+        end
+
+        private
+
+        def decode_array(var, deprecation_warning)
+          if var.is_a?(Array)
+            var.find.with_index do |env_var, i|
+              found = ENV.key?(env_var)
+
+              # Check if we are using a non-preferred environment variable
+              if deprecation_warning && found && i != 0
+                Datadog::Core.log_deprecation { "#{env_var} environment variable is deprecated, use #{var.first} instead." }
+              end
+
+              found
+            end
+          else
+            var
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Reports Ruby VM cache performance statistics.
+      # This currently encompasses cache invalidation counters and is CRuby-specific.
+      #
+      # JRuby emulates some CRuby global cache statistics, but they are synthetic and don't
+      # provide actionable performance information in the same way CRuby does.
+      # @see https://github.com/jruby/jruby/issues/4384#issuecomment-267069314
+      #
+      # TruffleRuby does not have a global runtime cache invalidation cache.
+      # @see http://archive.today/2021.09.10-205702/https://medium.com/graalvm/precise-method-and-constant-invalidation-in-truffleruby-4dd56c6bac1a
+      module VMCache
+        module_function
+
+        # Global constant cache "generation" counter.
+        #
+        # Whenever a constant creation busts the global constant cache
+        # this value is incremented. This has a measurable performance impact
+        # and thus show be avoided after application warm up.
+        #
+        # This was removed in Ruby 3.2.
+        # @see https://github.com/ruby/ruby/blob/master/doc/NEWS/NEWS-3.2.0.md#implementation-improvements
+        def global_constant_state
+          ::RubyVM.stat[:global_constant_state]
+        end
+
+        # Global method cache "generation" counter.
+        #
+        # Whenever a method creation busts the global method cache
+        # this value is incremented. This has a measurable performance impact
+        # and thus show be avoided after application warm up.
+        #
+        # Since Ruby 3.0, the method class is kept on a per-class basis,
+        # largely mitigating global method cache busting. `global_method_state`
+        # is thus not available since Ruby 3.0.
+        # @see https://bugs.ruby-lang.org/issues/16614
+        def global_method_state
+          ::RubyVM.stat[:global_method_state]
+        end
+
+        # Introduced in Ruby 3.2 to match an improved cache implementation.
+        #
+        # @see https://bugs.ruby-lang.org/issues/18589
+        def constant_cache_invalidations
+          ::RubyVM.stat[:constant_cache_invalidations]
+        end
+
+        # Introduced in Ruby 3.2 to match an improved cache implementation.
+        #
+        # @see https://bugs.ruby-lang.org/issues/18589
+        def constant_cache_misses
+          ::RubyVM.stat[:constant_cache_misses]
+        end
+
+        def available?
+          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Reports YJIT primitive runtime statistics.
+      module YJIT
+        module_function
+
+        # Inline code size
+        def inline_code_size
+          ::RubyVM::YJIT.runtime_stats[:inline_code_size]
+        end
+
+        # Outlined code size
+        def outlined_code_size
+          ::RubyVM::YJIT.runtime_stats[:outlined_code_size]
+        end
+
+        # GCed pages
+        def freed_page_count
+          ::RubyVM::YJIT.runtime_stats[:freed_page_count]
+        end
+
+        # GCed code size
+        def freed_code_size
+          ::RubyVM::YJIT.runtime_stats[:freed_code_size]
+        end
+
+        # Live pages
+        def live_page_count
+          ::RubyVM::YJIT.runtime_stats[:live_page_count]
+        end
+
+        # Code GC count
+        def code_gc_count
+          ::RubyVM::YJIT.runtime_stats[:code_gc_count]
+        end
+
+        # Size of memory region allocated for JIT code
+        def code_region_size
+          ::RubyVM::YJIT.runtime_stats[:code_region_size]
+        end
+
+        # Total number of object shapes
+        def object_shape_count
+          ::RubyVM::YJIT.runtime_stats[:object_shape_count]
+        end
+
+        def available?
+          defined?(::RubyVM::YJIT) \
+            && ::RubyVM::YJIT.enabled? \
+            && ::RubyVM::YJIT.respond_to?(:runtime_stats)
+        end
+      end
+    end
+  end
+end