cw-datadog 2.23.0.2

data/lib/datadog/core/diagnostics/environment_logger.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rbconfig'
+require 'time'
+
+module Datadog
+  module Core
+    module Diagnostics
+      # Base class for EnvironmentLoggers - should allow for easy reporting by users to Datadog support.
+      #
+      # The EnvironmentLogger should not pollute the logs in a development environment.
+      module EnvironmentLogging
+        def log_configuration!(prefix, data)
+          logger.info("DATADOG CONFIGURATION - #{prefix} - #{data}")
+        end
+
+        def log_debug!(prefix, data)
+          logger.debug("DATADOG CONFIGURATION - #{prefix} - #{data}")
+        end
+
+        def log_error!(prefix, type, error)
+          logger.warn("DATADOG ERROR - #{prefix} - #{type}: #{error}")
+        end
+
+        protected
+
+        def logger
+          Datadog.logger
+        end
+
+        # Are we logging the environment data?
+        def log?
+          startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
+          if startup_logs_enabled.nil?
+            # Do not pollute the logs in a development environment.
+            !Datadog::Core::Environment::Execution.development?
+          else
+            startup_logs_enabled
+          end
+        end
+      end
+
+      # Collects and logs Core diagnostic information
+      module EnvironmentLogger
+        extend EnvironmentLogging
+
+        def self.collect_and_log!(extra_fields = nil)
+          if log?
+            data = EnvironmentCollector.collect_config!
+            data = data.merge(extra_fields) if extra_fields
+            log_configuration!('CORE', data.to_json)
+          end
+        rescue => e
+          logger.warn("Failed to collect core environment information: #{e} Location: #{Array(e.backtrace).first}")
+        end
+      end
+
+      # Collects environment information for Core diagnostic logging
+      module EnvironmentCollector
+        class << self
+          def collect_config!
+            {
+              date: date,
+              os_name: os_name,
+              version: version,
+              lang: lang,
+              lang_version: lang_version,
+              env: env,
+              service: service,
+              dd_version: dd_version,
+              debug: debug,
+              tags: tags,
+              runtime_metrics_enabled: runtime_metrics_enabled,
+              vm: vm,
+              health_metrics_enabled: health_metrics_enabled
+            }
+          end
+
+          # @return [String] current time in ISO8601 format
+          def date
+            Core::Utils::Time.now.utc.iso8601
+          end
+
+          # Best portable guess of OS information.
+          # @return [String] platform string
+          def os_name
+            RbConfig::CONFIG['host']
+          end
+
+          # @return [String] datadog version
+          def version
+            Datadog::VERSION::STRING
+          end
+
+          # @return [String] "ruby"
+          def 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
+            Core::Environment::Ext::LANG_VERSION
+          end
+
+          # @return [String] configured application environment
+          def env
+            Datadog.configuration.env
+          end
+
+          # @return [String] configured application service name
+          def service
+            Datadog.configuration.service
+          end
+
+          # @return [String] configured application version
+          def dd_version
+            Datadog.configuration.version
+          end
+
+          # @return [Boolean, nil] debug mode enabled in configuration
+          def debug
+            !!Datadog.configuration.diagnostics.debug
+          end
+
+          # @return [Hash, nil] concatenated list of global tracer tags configured
+          def tags
+            tags = Datadog.configuration.tags
+            return nil if tags.empty?
+
+            hash_serializer(tags)
+          end
+
+          # @return [Boolean, nil] runtime metrics enabled in configuration
+          def runtime_metrics_enabled
+            Datadog.configuration.runtime_metrics.enabled
+          end
+
+          # Ruby VM name and version.
+          # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
+          # @return [String, nil]
+          def vm
+            # RUBY_ENGINE_VERSION returns the VM version, which
+            # will differ from RUBY_VERSION for non-mri VMs.
+            if defined?(RUBY_ENGINE_VERSION)
+              "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
+            else
+              # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
+              "#{RUBY_ENGINE}-#{RUBY_VERSION}"
+            end
+          end
+
+          # @return [Boolean, nil] health metrics enabled in configuration
+          def health_metrics_enabled
+            !!Datadog.configuration.health_metrics.enabled
+          end
+
+          private
+
+          # Outputs "k1:v1,k2:v2,..."
+          def hash_serializer(h)
+            h.map { |k, v| "#{k}:#{v}" }.join(',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/diagnostics/health.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../metrics/client'
+require_relative '../../tracing/diagnostics/health'
+
+module Datadog
+  module Core
+    module Diagnostics
+      # Health-related diagnostics
+      module Health
+        # Health metrics for diagnostics
+        class Metrics < Core::Metrics::Client
+          # TODO: Don't reference this. Have tracing add its metrics behavior.
+          extend Tracing::Diagnostics::Health::Metrics
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/encoding.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: 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
+        # :nocov:
+        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
+
+        # Deserializes a value serialized with {#encode}.
+        # This method is used for debugging purposes.
+        def decode(_)
+          raise NotImplementedError
+        end
+        # :nocov:
+      end
+
+      # Encoder for the JSON format
+      module JSONEncoder
+        extend Encoder
+
+        CONTENT_TYPE = 'application/json'
+
+        module_function
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          JSON.dump(obj)
+        end
+
+        def decode(obj)
+          JSON.parse(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'
+
+        def content_type
+          CONTENT_TYPE
+        end
+
+        def encode(obj)
+          MessagePack.pack(obj)
+        end
+
+        def decode(obj)
+          MessagePack.unpack(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/agent_info.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves the agent's `/info` endpoint data.
+      # This data can be used to determine the capabilities of the local Datadog agent.
+      #
+      # @example Example response payload
+      #   {
+      #     "version" : "7.57.2",
+      #     "git_commit" : "38ba0c7",
+      #     "endpoints" : [ "/v0.4/traces", "/v0.4/services", "/v0.7/traces", "/v0.7/config" ],
+      #     "client_drop_p0s" : true,
+      #     "span_meta_structs" : true,
+      #     "long_running_spans" : true,
+      #     "evp_proxy_allowed_headers" : [ "Content-Type", "Accept-Encoding", "Content-Encoding", "User-Agent" ],
+      #     "config" : {
+      #       "default_env" : "none",
+      #       "target_tps" : 10,
+      #       "max_eps" : 200,
+      #       "receiver_port" : 8126,
+      #       "receiver_socket" : "/var/run/datadog/apm.socket",
+      #       "connection_limit" : 0,
+      #       "receiver_timeout" : 0,
+      #       "max_request_bytes" : 26214400,
+      #       "statsd_port" : 8125,
+      #       "analyzed_spans_by_service" : { },
+      #       "obfuscation" : {
+      #         "elastic_search" : true,
+      #         "mongo" : true,
+      #         "sql_exec_plan" : false,
+      #         "sql_exec_plan_normalize" : false,
+      #         "http" : {
+      #           "remove_query_string" : false,
+      #           "remove_path_digits" : false
+      #         },
+      #         "remove_stack_traces" : false,
+      #         "redis" : {
+      #           "Enabled" : true,
+      #           "RemoveAllArgs" : false
+      #         },
+      #         "memcached" : {
+      #           "Enabled" : true,
+      #           "KeepCommand" : false
+      #         }
+      #       }
+      #     },
+      #     "peer_tags" : null
+      #   }
+      #
+      # @see https://github.com/DataDog/datadog-agent/blob/f07df0a3c1fca0c83b5a15f553bd994091b0c8ac/pkg/trace/api/info.go#L20
+      class AgentInfo
+        attr_reader :agent_settings, :logger
+
+        def initialize(agent_settings, logger: Datadog.logger)
+          @agent_settings = agent_settings
+          @logger = logger
+          @client = Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
+        end
+
+        # Fetches the information from the agent.
+        # @return [Datadog::Core::Remote::Transport::HTTP::Negotiation::Response] the response from the agent
+        # @return [nil] if an error occurred while fetching the information
+        def fetch
+          res = @client.send_info
+          return unless res.ok?
+
+          res
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && other.agent_settings == agent_settings
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '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|
+            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 => e
+            Datadog.logger.error(
+              "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            )
+          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 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves number of classes from runtime
+      module ClassCount
+        def self.value
+          ::ObjectSpace.count_objects[:T_CLASS]
+        end
+
+        def self.available?
+          return @class_count_available if defined?(@class_count_available)
+
+          @class_count_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,89 @@
+# frozen_string_literal: true
+
+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}'
+        CONTAINER_PATTERN = '[0-9a-f]{64}'
+
+        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|
+            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 => 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

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,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../datadog/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
+            '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'
+
+        GEM_DATADOG_VERSION = Datadog::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