datadog 2.0.0.beta1 → 2.0.0.beta2

data/lib/datadog/core/telemetry/collector.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require 'etc'
-
-require_relative '../configuration/agent_settings_resolver'
-require_relative '../environment/ext'
-require_relative '../environment/platform'
-require_relative '../utils/hash'
-require_relative 'v1/application'
-require_relative 'v1/dependency'
-require_relative 'v1/host'
-require_relative 'v1/install_signature'
-require_relative 'v1/integration'
-require_relative 'v1/product'
-require_relative '../transport/ext'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Module defining methods for collecting metadata for telemetry
-      module Collector
-        include Datadog::Core::Configuration
-        using Core::Utils::Hash::Refinement
-
-        # Forms a hash of configuration key value pairs to be sent in the additional payload
-        def additional_payload
-          additional_payload_variables
-        end
-
-        # Forms a telemetry application object
-        def application
-          Telemetry::V1::Application.new(
-            env: env,
-            language_name: Datadog::Core::Environment::Ext::LANG,
-            language_version: Datadog::Core::Environment::Ext::LANG_VERSION,
-            products: products,
-            runtime_name: Datadog::Core::Environment::Ext::RUBY_ENGINE,
-            runtime_version: Datadog::Core::Environment::Ext::ENGINE_VERSION,
-            service_name: service_name,
-            service_version: service_version,
-            tracer_version: library_version
-          )
-        end
-
-        # Forms a hash of standard key value pairs to be sent in the app-started event configuration
-        def configurations
-          config = Datadog.configuration
-          hash = {
-            DD_AGENT_HOST: config.agent.host,
-            DD_AGENT_TRANSPORT: agent_transport,
-            DD_TRACE_SAMPLE_RATE: format_configuration_value(config.tracing.sampling.default_rate),
-            DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED: config.tracing.contrib.global_default_service_name.enabled
-          }
-          peer_service_mapping_str = ''
-          unless config.tracing.contrib.peer_service_mapping.empty?
-            peer_service_mapping = config.tracing.contrib.peer_service_mapping
-            peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
-          end
-          hash[:DD_TRACE_PEER_SERVICE_MAPPING] = peer_service_mapping_str
-          hash.compact!
-          hash
-        end
-
-        # Forms a telemetry app-started dependencies object
-        def dependencies
-          Gem.loaded_specs.collect do |name, loaded_gem|
-            Datadog::Core::Telemetry::V1::Dependency.new(
-              # `hash` should be used when `version` is not available
-              name: name, version: loaded_gem.version.to_s, hash: nil
-            )
-          end
-        end
-
-        # Forms a telemetry host object
-        def host
-          Telemetry::V1::Host.new(
-            container_id: Core::Environment::Container.container_id,
-            hostname: Core::Environment::Platform.hostname,
-            kernel_name: Core::Environment::Platform.kernel_name,
-            kernel_release: Core::Environment::Platform.kernel_release,
-            kernel_version: Core::Environment::Platform.kernel_version
-          )
-        end
-
-        # Forms a telemetry app-started install_signature object
-        def install_signature
-          Telemetry::V1::InstallSignature.new(
-            install_id: Datadog.configuration.dig('telemetry', 'install_id'),
-            install_type: Datadog.configuration.dig('telemetry', 'install_type'),
-            install_time: Datadog.configuration.dig('telemetry', 'install_time'),
-          )
-        end
-
-        # Forms a telemetry app-started integrations object
-        def integrations
-          Datadog.registry.map do |integration|
-            is_instrumented = instrumented?(integration)
-            is_enabled = is_instrumented && patched?(integration)
-            Telemetry::V1::Integration.new(
-              name: integration.name.to_s,
-              enabled: is_enabled,
-              version: integration_version(integration),
-              compatible: integration_compatible?(integration),
-              error: (patch_error(integration) if is_instrumented && !is_enabled),
-              auto_enabled: is_enabled ? integration_auto_instrument?(integration) : nil
-            )
-          end
-        end
-
-        # Returns the runtime ID of the current process
-        def runtime_id
-          Datadog::Core::Environment::Identity.id
-        end
-
-        # Returns the current as a UNIX timestamp in seconds
-        def tracer_time
-          Time.now.to_i
-        end
-
-        private
-
-        TARGET_OPTIONS = [
-          'logger.level',
-          'profiling.advanced.code_provenance_enabled',
-          'profiling.advanced.endpoint.collection.enabled',
-          'profiling.enabled',
-          'runtime_metrics.enabled',
-          'tracing.analytics.enabled',
-          'tracing.propagation_style_inject',
-          'tracing.propagation_style_extract',
-          'tracing.enabled',
-          'tracing.log_injection',
-          'tracing.partial_flush.enabled',
-          'tracing.partial_flush.min_spans_threshold',
-          'tracing.report_hostname',
-          'tracing.sampling.default_rate',
-          'tracing.sampling.rate_limit'
-        ].freeze
-
-        def additional_payload_variables
-          # Whitelist of configuration options to send in additional payload object
-          configuration = Datadog.configuration
-          options = TARGET_OPTIONS.each_with_object({}) do |option, hash|
-            split_option = option.split('.')
-            hash[option] = format_configuration_value(configuration.dig(*split_option))
-          end
-
-          # Add some more custom additional payload values here
-          options['tracing.auto_instrument.enabled'] = !defined?(Datadog::AutoInstrument::LOADED).nil?
-          options['tracing.writer_options.buffer_size'] =
-            format_configuration_value(configuration.tracing.writer_options[:buffer_size])
-          options['tracing.writer_options.flush_interval'] =
-            format_configuration_value(configuration.tracing.writer_options[:flush_interval])
-          options['logger.instance'] = configuration.logger.instance.class.to_s
-          options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
-          options['ci.enabled'] = configuration.dig('ci', 'enabled') if configuration.respond_to?('ci')
-          options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
-          options.compact!
-          options
-        end
-
-        def format_configuration_value(value)
-          # TODO: Add float if telemetry starts accepting it
-          case value
-          when Integer, String, true, false, nil
-            value
-          else
-            value.to_s
-          end
-        end
-
-        def env
-          Datadog.configuration.env
-        end
-
-        def service_name
-          Datadog.configuration.service
-        end
-
-        def service_version
-          Datadog.configuration.version
-        end
-
-        def library_version
-          Core::Environment::Identity.gem_datadog_version
-        end
-
-        def products
-          Telemetry::V1::Product.new(profiler: profiler, appsec: appsec)
-        end
-
-        def profiler
-          { version: library_version }
-        end
-
-        def appsec
-          { version: library_version }
-        end
-
-        def agent_transport
-          adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
-          if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
-            'UDS'
-          else
-            'TCP'
-          end
-        end
-
-        def instrumented_integrations
-          Datadog.configuration.tracing.instrumented_integrations
-        end
-
-        def instrumented?(integration)
-          instrumented_integrations.include?(integration.name)
-        end
-
-        def patched?(integration)
-          !!integration.klass.patcher.patch_successful
-        end
-
-        def integration_auto_instrument?(integration)
-          integration.klass.auto_instrument?
-        end
-
-        def integration_compatible?(integration)
-          integration.klass.class.compatible?
-        end
-
-        def integration_version(integration)
-          integration.klass.class.version ? integration.klass.class.version.to_s : nil
-        end
-
-        def patch_error(integration)
-          patch_error_result = integration.klass.patcher.patch_error_result
-          if patch_error_result.nil? # if no error occurred during patching, but integration is still not instrumented
-            desc = "Available?: #{integration.klass.class.available?}"
-            desc += ", Loaded? #{integration.klass.class.loaded?}"
-            desc += ", Compatible? #{integration.klass.class.compatible?}"
-            desc += ", Patchable? #{integration.klass.class.patchable?}"
-            desc
-          else
-            patch_error_result.compact.to_s
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/app_event.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes payload for telemetry V1 API app-integrations-change event
-        class AppEvent
-          attr_reader \
-            :additional_payload,
-            :configuration,
-            :dependencies,
-            :install_signature,
-            :integrations
-
-          # @param additional_payload [Array<Telemetry::V1::Configuration>] List of Additional payload to track (any key
-          #   value not mentioned and doesn't fit under a metric)
-          # @param configuration [Array<Telemetry::V1::Configuration>] List of Tracer related configuration data
-          # @param dependencies [Array<Telemetry::V1::Dependency>] List of all loaded modules requested by the app
-          # @param install_signature [Telemetry::V1::InstallSignature] Install signature data
-          # @param integrations [Array<Telemetry::V1::Integration>] List of integrations that are available within the app
-          #   and applicable to be traced
-          def initialize(
-            additional_payload: nil, configuration: nil, dependencies: nil, install_signature: nil,
-            integrations: nil
-          )
-            @additional_payload = additional_payload
-            @configuration = configuration
-            @dependencies = dependencies
-            @install_signature = install_signature
-            @integrations = integrations
-          end
-
-          def to_h
-            {}.tap do |hash|
-              hash[:additional_payload] = map_hash(@additional_payload) if @additional_payload
-              hash[:configuration] = map_hash(@configuration) if @configuration
-              hash[:dependencies] = map_array(@dependencies) if @dependencies
-              hash[:install_signature] = @install_signature.to_h if @install_signature
-              hash[:integrations] = map_array(@integrations) if @integrations
-            end
-          end
-
-          private
-
-          def map_hash(hash)
-            hash.map do |k, v|
-              { name: k.to_s, value: v }
-            end
-          end
-
-          def map_array(arr)
-            arr.map(&:to_h)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/application.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/hash'
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for application environment object
-        class Application
-          using Core::Utils::Hash::Refinement
-
-          ERROR_NIL_LANGUAGE_NAME_MESSAGE = ':language_name must not be nil'
-          ERROR_NIL_LANGUAGE_VERSION_MESSAGE = ':language_version must not be nil'
-          ERROR_NIL_SERVICE_NAME_MESSAGE = ':service_name must not be nil'
-          ERROR_NIL_TRACER_VERSION_MESSAGE = ':tracer_version must not be nil'
-
-          attr_reader \
-            :env,
-            :language_name,
-            :language_version,
-            :products,
-            :runtime_name,
-            :runtime_patches,
-            :runtime_version,
-            :service_name,
-            :service_version,
-            :tracer_version
-
-          # @param env [String] Service's environment
-          # @param language_name [String] 'ruby'
-          # @param language_version [String] Version of language used
-          # @param products [Telemetry::V1::Product] Contains information about specific products added to the environment
-          # @param runtime_name [String] Runtime being used
-          # @param runtime_patches [String] String of patches applied to the runtime
-          # @param runtime_version [String] Runtime version; potentially the same as :language_version
-          # @param service_name [String] Service’s name (DD_SERVICE)
-          # @param service_version [String] Service’s version (DD_VERSION)
-          # @param tracer_version [String] Version of the used tracer
-          def initialize(
-            language_name:, language_version:, service_name:, tracer_version:, env: nil, products: nil,
-            runtime_name: nil, runtime_patches: nil, runtime_version: nil, service_version: nil
-          )
-            validate(
-              language_name: language_name,
-              language_version: language_version,
-              service_name: service_name,
-              tracer_version: tracer_version
-            )
-            @env = env
-            @language_name = language_name
-            @language_version = language_version
-            @products = products
-            @runtime_name = runtime_name
-            @runtime_patches = runtime_patches
-            @runtime_version = runtime_version
-            @service_name = service_name
-            @service_version = service_version
-            @tracer_version = tracer_version
-          end
-
-          def to_h
-            hash = {
-              env: @env,
-              language_name: @language_name,
-              language_version: @language_version,
-              products: @products.to_h,
-              runtime_name: @runtime_name,
-              runtime_patches: @runtime_patches,
-              runtime_version: @runtime_version,
-              service_name: @service_name,
-              service_version: @service_version,
-              tracer_version: @tracer_version
-            }
-            hash.compact!
-            hash
-          end
-
-          private
-
-          # Validates required arguments passed to the class on initialization are not nil
-          #
-          # @!visibility private
-          def validate(language_name:, language_version:, service_name:, tracer_version:)
-            raise ArgumentError, ERROR_NIL_LANGUAGE_NAME_MESSAGE if language_name.nil?
-            raise ArgumentError, ERROR_NIL_LANGUAGE_VERSION_MESSAGE if language_version.nil?
-            raise ArgumentError, ERROR_NIL_SERVICE_NAME_MESSAGE if service_name.nil?
-            raise ArgumentError, ERROR_NIL_TRACER_VERSION_MESSAGE if tracer_version.nil?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/configuration.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for additional payload or configuration object
-        class Configuration
-          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'
-
-          attr_reader \
-            :name,
-            :value
-
-          # @param name [String] Configuration/additional payload attribute name
-          # @param value [String, Integer, Boolean] Corresponding value
-          def initialize(name:, value: nil)
-            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
-
-            @name = name
-            @value = value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/dependency.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/hash'
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for dependency object
-        class Dependency
-          using Core::Utils::Hash::Refinement
-
-          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'
-
-          attr_reader \
-            :hash,
-            :name,
-            :version
-
-          # @param name [String] Module name
-          # @param version [String] Version of resolved module
-          # @param hash [String] Dependency hash, in case `version` is not available
-          def initialize(name:, version: nil, hash: nil)
-            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
-            raise ArgumentError, 'if both :version and :hash exist, use :version only' if version && hash
-
-            @hash = hash
-            @name = name
-            @version = version
-          end
-
-          def to_h
-            hash = {
-              hash: @hash,
-              name: @name,
-              version: @version
-            }
-            hash.compact!
-            hash
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/host.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/hash'
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for host object
-        class Host
-          using Core::Utils::Hash::Refinement
-
-          attr_reader \
-            :container_id,
-            :hostname,
-            :kernel_name,
-            :kernel_release,
-            :kernel_version,
-            :os_version,
-            :os
-
-          # @param container_id [String] Docker container ID
-          # @param hostname [String] uname -n
-          # @param kernel_name [String] uname -s
-          # @param kernel_release [String] uname -r
-          # @param kernel_version [String] uname -v
-          # @param os [String] uname -o
-          # @param os_version [String] Version of OS running
-          def initialize(
-            container_id: nil, hostname: nil, kernel_name: nil, kernel_release: nil, kernel_version: nil,
-            os_version: nil, os: nil
-          )
-            @container_id = container_id
-            @hostname = hostname
-            @kernel_name = kernel_name
-            @kernel_release = kernel_release
-            @kernel_version = kernel_version
-            @os = os
-            @os_version = os_version
-          end
-
-          def to_h
-            hash = {
-              container_id: @container_id,
-              hostname: @hostname,
-              kernel_name: @kernel_name,
-              kernel_release: @kernel_release,
-              kernel_version: @kernel_version,
-              os: @os,
-              os_version: @os_version,
-            }
-            hash.compact!
-            hash
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/install_signature.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for install signature
-        class InstallSignature
-          using Core::Utils::Hash::Refinement
-
-          attr_reader \
-            :install_id,
-            :install_type,
-            :install_time
-
-          # @param id [String,nil] Install ID
-          # @param type [String,nil] Install type
-          # @param type [String,nil] Install time
-          def initialize(install_id:, install_type:, install_time:)
-            @install_id = install_id
-            @install_type = install_type
-            @install_time = install_time
-          end
-
-          def to_h
-            hash = {
-              install_id: @install_id,
-              install_type: @install_type,
-              install_time: @install_time
-            }
-            hash.compact!
-            hash
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/integration.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/hash'
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for integration object
-        class Integration
-          using Core::Utils::Hash::Refinement
-
-          ERROR_NIL_ENABLED_MESSAGE = ':enabled must not be nil'
-          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'
-
-          attr_reader \
-            :auto_enabled,
-            :compatible,
-            :enabled,
-            :error,
-            :name,
-            :version
-
-          # @param enabled [Boolean] Whether integration is enabled at time of request
-          # @param name [String] Integration name
-          # @param auto_enabled [Boolean] If integration is not enabled by default, but by user choice
-          # @param compatible [Boolean] If integration is available, but incompatible
-          # @param error [String] Error message if integration fails to load
-          # @param version [String] Integration version (if specified in app-started, it should be for other events too)
-          def initialize(enabled:, name:, auto_enabled: nil, compatible: nil, error: nil, version: nil)
-            validate(enabled: enabled, name: name)
-            @auto_enabled = auto_enabled
-            @compatible = compatible
-            @enabled = enabled
-            @error = error
-            @name = name
-            @version = version
-          end
-
-          def to_h
-            hash = {
-              auto_enabled: @auto_enabled,
-              compatible: @compatible,
-              enabled: @enabled,
-              error: @error,
-              name: @name,
-              version: @version
-            }
-            hash.compact!
-            hash
-          end
-
-          private
-
-          # Validates all required arguments passed to the class on initialization are not nil
-          #
-          # @!visibility private
-          def validate(enabled:, name:)
-            raise ArgumentError, ERROR_NIL_ENABLED_MESSAGE if enabled.nil?
-            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/v1/product.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/hash'
-
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for products object
-        class Product
-          using Core::Utils::Hash::Refinement
-
-          attr_reader \
-            :appsec,
-            :profiler
-
-          # @param appsec [Telemetry::V1::AppSec] Holds custom information about the appsec product
-          # @param profiler [Telemetry::V1::Profiler] Holds custom information about the profiler product
-          def initialize(appsec: nil, profiler: nil)
-            @appsec = appsec
-            @profiler = profiler
-          end
-
-          def to_h
-            hash = {
-              appsec: @appsec,
-              profiler: @profiler
-            }
-            hash.compact!
-            hash
-          end
-        end
-      end
-    end
-  end
-end