ddtrace 0.50.0 → 1.0.0

data/lib/datadog/core/encoding.rb

@@ -0,0 +1,76 @@
+# typed: true
+
+require 'json'
+require 'msgpack'
+
+module Datadog
+  module Core
+    # Encoding module that encodes data for the AgentTransport
+    module Encoding
+      # Encoder interface that provides the logic to encode traces and service
+      # @abstract
+      module Encoder
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        def content_type
+          raise NotImplementedError
+        end
+
+        # Concatenates a list of elements previously encoded by +#encode+.
+        def join(encoded_elements)
+          raise NotImplementedError
+        end
+
+        # Serializes a single trace into a String suitable for network transmission.
+        def encode(_)
+          raise NotImplementedError
+        end
+      end
+
+      # Encoder for the JSON format
+      module JSONEncoder
+        extend Encoder
+
+        CONTENT_TYPE = 'application/json'.freeze
+
+        module_function
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          JSON.dump(obj)
+        end
+
+        def join(encoded_data)
+          "[#{encoded_data.join(',')}]"
+        end
+      end
+
+      # Encoder for the Msgpack format
+      module MsgpackEncoder
+        extend Encoder
+
+        module_function
+
+        CONTENT_TYPE = 'application/msgpack'.freeze
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          MessagePack.pack(obj)
+        end
+
+        def join(encoded_data)
+          packer = MessagePack::Packer.new
+          packer.write_array_header(encoded_data.size)
+
+          (packer.buffer.to_a + encoded_data).join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# typed: true
+
+require 'datadog/core/environment/ext'
+
+module Datadog
+  module Core
+    module Environment
+      # Reads information from Linux cgroups.
+      # This information is used to extract information
+      # about the current Linux container identity.
+      # @see https://man7.org/linux/man-pages/man7/cgroups.7.html
+      module Cgroup
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        LINE_REGEX = /^(\d+):([^:]*):(.+)$/.freeze
+
+        Descriptor = Struct.new(
+          :id,
+          :groups,
+          :path,
+          :controllers
+        )
+
+        module_function
+
+        def descriptors(process = 'self')
+          [].tap do |descriptors|
+            begin
+              filepath = "/proc/#{process}/cgroup"
+
+              if File.exist?(filepath)
+                File.foreach("/proc/#{process}/cgroup") do |line|
+                  line = line.strip
+                  descriptors << parse(line) unless line.empty?
+                end
+              end
+            rescue StandardError => e
+              Datadog.logger.error("Error while parsing cgroup. Cause: #{e.message} Location: #{Array(e.backtrace).first}")
+            end
+          end
+        end
+
+        def parse(line)
+          id, groups, path = line.scan(LINE_REGEX).first
+
+          Descriptor.new(id, groups, path).tap do |descriptor|
+            descriptor.controllers = groups.split(',') unless groups.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves number of classes from runtime
+      module ClassCount
+        module_function
+
+        def value
+          ::ObjectSpace.count_objects[:T_CLASS]
+        end
+
+        def available?
+          ::ObjectSpace.respond_to?(:count_objects) \
+           && ::ObjectSpace.count_objects.key?(:T_CLASS)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# typed: true
+
+require 'datadog/core/environment/cgroup'
+
+module Datadog
+  module Core
+    module Environment
+      # For container environments
+      module Container
+        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+        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.message} Location: #{Array(e.backtrace).first}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: true
+
+require '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'.freeze
+        ENV_ENVIRONMENT = 'DD_ENV'.freeze
+        ENV_SERVICE = 'DD_SERVICE'.freeze
+        ENV_SITE = 'DD_SITE'.freeze
+        ENV_TAGS = 'DD_TAGS'.freeze
+        ENV_VERSION = 'DD_VERSION'.freeze
+        FALLBACK_SERVICE_NAME =
+          begin
+            File.basename($PROGRAM_NAME, '.*')
+          rescue StandardError
+            'ruby'
+          end.freeze
+
+        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'
+        TAG_ENV = 'env'.freeze
+        TAG_SERVICE = 'service'.freeze
+        TAG_VERSION = 'version'.freeze
+
+        # 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 @@
+# typed: 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/identity.rb

@@ -0,0 +1,58 @@
+# typed: false
+
+require 'securerandom'
+
+require 'datadog/core/environment/ext'
+require 'datadog/core/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
+
+        def tracer_version
+          Core::Environment::Ext::TRACER_VERSION
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# typed: false
+
+require 'socket'
+require 'datadog/core/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 @@
+# typed: 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,44 @@
+# typed: false
+
+module Datadog
+  module Core
+    # Namespace for handling application environment
+    module Environment
+      # Defines helper methods for environment
+      # @public_api
+      module VariableHelpers
+        extend self
+
+        def env_to_bool(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_s.strip.downcase == 'true' : default
+        end
+
+        def env_to_int(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_i : default
+        end
+
+        def env_to_float(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_f : default
+        end
+
+        def env_to_list(var, default = [])
+          var = decode_array(var)
+          if var && ENV.key?(var)
+            ENV[var].split(',').map(&:strip)
+          else
+            default
+          end
+        end
+
+        private
+
+        def decode_array(var)
+          var.is_a?(Array) ? var.find { |env_var| ENV.key?(env_var) } : var
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# typed: 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.
+        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
+
+        def available?
+          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/error.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/core/utils'
+
+module Datadog
+  module Core
+    # Error is a value-object responsible for sanitizing/encapsulating error data
+    class Error
+      attr_reader :type, :message, :backtrace
+
+      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") unless backtrace.is_a?(String)
+
+        @type = Utils.utf8_encode(type)
+        @message = Utils.utf8_encode(message)
+        @backtrace = Utils.utf8_encode(backtrace)
+      end
+
+      BlankError = Error.new
+      ContainsMessage = ->(v) { v.respond_to?(:message) }
+    end
+  end
+end

data/lib/datadog/core/extensions.rb

@@ -0,0 +1,16 @@
+# typed: true
+
+require 'datadog/core/configuration'
+
+# Global namespace that includes all Datadog functionality.
+# @public_api
+module Datadog
+  module Core
+    # Used to decorate Datadog module with additional behavior
+    module Extensions
+      def self.extended(base)
+        base.extend(Core::Configuration)
+      end
+    end
+  end
+end

data/lib/datadog/core/git/ext.rb

@@ -0,0 +1,35 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Git
+      # Defines constants for Git tags
+      module Ext
+        TAG_BRANCH = 'git.branch'.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
+
+        ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'.freeze
+        ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'.freeze
+        ENV_BRANCH = 'DD_GIT_BRANCH'.freeze
+        ENV_TAG = 'DD_GIT_TAG'.freeze
+        ENV_COMMIT_MESSAGE = 'DD_GIT_COMMIT_MESSAGE'.freeze
+        ENV_COMMIT_AUTHOR_NAME = 'DD_GIT_COMMIT_AUTHOR_NAME'.freeze
+        ENV_COMMIT_AUTHOR_EMAIL = 'DD_GIT_COMMIT_AUTHOR_EMAIL'.freeze
+        ENV_COMMIT_AUTHOR_DATE = 'DD_GIT_COMMIT_AUTHOR_DATE'.freeze
+        ENV_COMMIT_COMMITTER_NAME = 'DD_GIT_COMMIT_COMMITTER_NAME'.freeze
+        ENV_COMMIT_COMMITTER_EMAIL = 'DD_GIT_COMMIT_COMMITTER_EMAIL'.freeze
+        ENV_COMMIT_COMMITTER_DATE = 'DD_GIT_COMMIT_COMMITTER_DATE'.freeze
+      end
+    end
+  end
+end