Rename Runtime to Environment (#1570)

Author: marcotc

.rubocop_todo.yml

@@ -79,7 +79,6 @@ Lint/MissingCopEnableDirective:
     - 'spec/ddtrace/contrib/rails/support/database.rb'
     - 'spec/ddtrace/contrib/rails/support/middleware.rb'
     - 'spec/ddtrace/diagnostics/health_spec.rb'
-    - 'spec/ddtrace/runtime/cgroup_spec.rb'
     - 'spec/support/container_helpers.rb'
     - 'spec/support/tracer_helpers.rb'
     - 'test/contrib/rails/controller_test.rb'

integration/images/include/datadog/demo_env.rb

@@ -1,23 +1,24 @@
 module Datadog
+  # Helpers to read the application environment
   module DemoEnv
     module_function
 
     def gem_spec(gem_name, defaults = {})
-      args =  if local_gem(gem_name)
-                [local_gem(gem_name)]
-              elsif git_gem(gem_name)
-                [git_gem(gem_name)]
-              else
-                []
-              end
+      args = if local_gem(gem_name)
+               [local_gem(gem_name)]
+             elsif git_gem(gem_name)
+               [git_gem(gem_name)]
+             else
+               []
+             end
 
       yield(args) if block_given?
 
       args
     end
 
     def gem_env_name(gem_name)
-      gem_name.upcase.gsub('-', '_')
+      gem_name.upcase.tr('-', '_')
     end
 
     def local_gem(gem_name)
@@ -55,11 +56,11 @@ def print_env(header = 'Datadog test environment')
       puts "Features: #{features}"
       puts "Rails env: #{ENV['RAILS_ENV']}" if ENV['RAILS_ENV']
       puts "PID: #{Process.pid}"
-      if ddtrace = Gem.loaded_specs['ddtrace']
-        puts "Runtime ID: #{Datadog::Runtime::Identity.id}" if defined?(Datadog::Runtime::Identity)
+      if (ddtrace = Gem.loaded_specs['ddtrace'])
+        puts "Runtime ID: #{Datadog::Core::Environment::Identity.id}" if defined?(Datadog::Core::Environment::Identity)
         puts "ddtrace version: #{ddtrace.version}"
         puts "ddtrace path: #{ddtrace.full_gem_path}"
-        if git_spec = git_gem('ddtrace')
+        if (git_spec = git_gem('ddtrace'))
           puts "ddtrace git: #{git_spec[:git]}"
           puts "ddtrace ref: #{git_spec[:ref]}"
         end
@@ -69,10 +70,10 @@ def print_env(header = 'Datadog test environment')
 
     def profiler_file_transport(dump_path = "/data/profile-pid-#{Process.pid}.pprof")
       Datadog::Profiling::Transport::IO.default(
-        write: ->(out, data) do
+        write: lambda do |_out, data|
           result = nil
           puts "Writing pprof #{dump_path}..."
-          File.open(dump_path, "w") { |f| result = f.write(data) }
+          File.open(dump_path, 'w') { |f| result = f.write(data) }
           puts "Pprof #{dump_path} written!"
           result
         end
@@ -86,7 +87,7 @@ def start_mem_dump!
 
     def finish_mem_dump!(dump_path = "/data/mem-pid-#{Process.pid}.dump")
       File.delete(dump_path) if File.exist?(dump_path)
-      File.open(dump_path, "w") do |io|
+      File.open(dump_path, 'w') do |io|
         ObjectSpace.dump_all(output: io)
       end
     end

lib/datadog/core/environment/cgroup.rb

@@ -0,0 +1,49 @@
+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
+        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: #{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

lib/datadog/core/environment/class_count.rb

@@ -0,0 +1,19 @@
+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

lib/datadog/core/environment/container.rb

@@ -0,0 +1,88 @@
+require 'datadog/core/environment/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]{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]
+                  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: #{e.backtrace.first}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/datadog/core/environment/ext.rb

@@ -0,0 +1,18 @@
+require 'ddtrace/version'
+
+module Datadog
+  module Core
+    module Environment
+      module Ext
+        # 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
+      end
+    end
+  end
+end

lib/datadog/core/environment/gc.rb

@@ -0,0 +1,18 @@
+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

lib/datadog/core/environment/identity.rb

@@ -0,0 +1,50 @@
+require 'securerandom'
+require 'datadog/core/environment/ext'
+require 'ddtrace/utils/forking'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      module Identity
+        extend Datadog::Utils::Forking
+
+        module_function
+
+        # Retrieves number of classes from runtime
+        def id
+          @id ||= SecureRandom.uuid
+
+          # Check if runtime has changed, e.g. forked.
+          after_fork! { @id = SecureRandom.uuid }
+
+          @id
+        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

lib/datadog/core/environment/object_space.rb

@@ -0,0 +1,22 @@
+require 'objspace'
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves garbage collection statistics
+      # DEV: Currently only used for testing.
+      module ObjectSpace
+        module_function
+
+        def estimate_bytesize(object)
+          return 0 unless ::ObjectSpace.respond_to?(:memsize_of)
+
+          # Rough calculation of bytesize; not very accurate.
+          object.instance_variables.inject(::ObjectSpace.memsize_of(object)) do |sum, var|
+            sum + ::ObjectSpace.memsize_of(object.instance_variable_get(var))
+          end
+        end
+      end
+    end
+  end
+end

lib/datadog/core/environment/socket.rb

@@ -0,0 +1,16 @@
+require 'socket'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      module Socket
+        module_function
+
+        def hostname
+          ::Socket.gethostname
+        end
+      end
+    end
+  end
+end

lib/datadog/core/environment/thread_count.rb

@@ -0,0 +1,18 @@
+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