ddtrace 1.4.2 → 1.23.3

data/lib/datadog/ci/test.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-# typed: false
-
-require_relative '../tracing/contrib/analytics'
-
-require_relative 'ext/app_types'
-require_relative 'ext/test'
-
-require 'rbconfig'
-
-module Datadog
-  module CI
-    # Common behavior for CI tests
-    module Test
-      # Creates a new span for a CI test
-      def self.trace(span_name, options = {})
-        span_options = {
-          span_type: Ext::AppTypes::TYPE_TEST
-        }.merge(options[:span_options] || {})
-
-        if block_given?
-          Tracing.trace(span_name, **span_options) do |span, trace|
-            set_tags!(trace, span, options)
-            yield(span, trace)
-          end
-        else
-          span = Tracing.trace(span_name, **span_options)
-          trace = Tracing.active_trace
-          set_tags!(trace, span, options)
-          span
-        end
-      end
-
-      # Adds tags to a CI test span.
-      def self.set_tags!(trace, span, tags = {})
-        tags ||= {}
-
-        # Set default tags
-        trace.origin = Ext::Test::CONTEXT_ORIGIN if trace
-        Datadog::Tracing::Contrib::Analytics.set_measured(span)
-        span.set_tag(Ext::Test::TAG_SPAN_KIND, Ext::AppTypes::TYPE_TEST)
-
-        # Set environment tags
-        @environment_tags ||= Ext::Environment.tags(ENV)
-        @environment_tags.each { |k, v| span.set_tag(k, v) }
-
-        # Set contextual tags
-        span.set_tag(Ext::Test::TAG_FRAMEWORK, tags[:framework]) if tags[:framework]
-        span.set_tag(Ext::Test::TAG_FRAMEWORK_VERSION, tags[:framework_version]) if tags[:framework_version]
-        span.set_tag(Ext::Test::TAG_NAME, tags[:test_name]) if tags[:test_name]
-        span.set_tag(Ext::Test::TAG_SUITE, tags[:test_suite]) if tags[:test_suite]
-        span.set_tag(Ext::Test::TAG_TYPE, tags[:test_type]) if tags[:test_type]
-
-        set_environment_runtime_tags!(span)
-
-        span
-      end
-
-      def self.passed!(span)
-        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::PASS)
-      end
-
-      def self.failed!(span, exception = nil)
-        span.status = 1
-        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::FAIL)
-        span.set_error(exception) unless exception.nil?
-      end
-
-      def self.skipped!(span, exception = nil)
-        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::SKIP)
-        span.set_error(exception) unless exception.nil?
-      end
-
-      private_class_method def self.set_environment_runtime_tags!(span)
-        span.set_tag(Ext::Test::TAG_OS_ARCHITECTURE, ::RbConfig::CONFIG['host_cpu'])
-        span.set_tag(Ext::Test::TAG_OS_PLATFORM, ::RbConfig::CONFIG['host_os'])
-        span.set_tag(Ext::Test::TAG_RUNTIME_NAME, Core::Environment::Ext::LANG_ENGINE)
-        span.set_tag(Ext::Test::TAG_RUNTIME_VERSION, Core::Environment::Ext::ENGINE_VERSION)
-      end
-    end
-  end
-end

data/lib/datadog/ci.rb

@@ -1,20 +0,0 @@
-# typed: strict
-
-require_relative 'core'
-require_relative 'tracing'
-require_relative 'tracing/contrib'
-
-module Datadog
-  # Namespace for Datadog CI instrumentation:
-  # e.g. rspec, cucumber, etc...
-  module CI
-  end
-end
-
-# Integrations
-require_relative 'ci/contrib/cucumber/integration'
-require_relative 'ci/contrib/rspec/integration'
-
-# Extensions
-require_relative 'ci/extensions'
-Datadog::CI::Extensions.activate!

data/lib/datadog/core/configuration/dependency_resolver.rb

@@ -1,28 +0,0 @@
-# typed: false
-
-require 'tsort'
-
-module Datadog
-  module Core
-    module Configuration
-      # Resolver performs a topological sort over the dependency graph
-      class DependencyResolver
-        include TSort
-
-        def initialize(dependency_graph = {})
-          @dependency_graph = dependency_graph
-        end
-
-        def tsort_each_node(&blk)
-          @dependency_graph.each_key(&blk)
-        end
-
-        def tsort_each_child(node, &blk)
-          @dependency_graph.fetch(node).each(&blk)
-        end
-
-        alias call tsort
-      end
-    end
-  end
-end

data/lib/datadog/core/configuration/option_definition_set.rb

@@ -1,22 +0,0 @@
-# typed: true
-
-require_relative 'dependency_resolver'
-
-module Datadog
-  module Core
-    module Configuration
-      # Represents a set of configuration option definitions for an integration
-      class OptionDefinitionSet < Hash
-        def dependency_order
-          DependencyResolver.new(dependency_graph).call
-        end
-
-        def dependency_graph
-          each_with_object({}) do |(name, option), graph|
-            graph[name] = option.depends_on
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/configuration/option_set.rb

@@ -1,10 +0,0 @@
-# typed: true
-
-module Datadog
-  module Core
-    module Configuration
-      class OptionSet < Hash
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# typed: true
-
-require_relative 'emitter'
-require_relative 'heartbeat'
-require_relative '../utils/forking'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecyle
-      class Client
-        attr_reader \
-          :emitter,
-          :enabled,
-          :unsupported,
-          :worker
-
-        include Core::Utils::Forking
-
-        # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
-        def initialize(enabled: true)
-          @enabled = enabled
-          @emitter = Emitter.new
-          @stopped = false
-          @unsupported = false
-          @worker = Telemetry::Heartbeat.new(enabled: @enabled) do
-            heartbeat!
-          end
-        end
-
-        def disable!
-          @enabled = false
-          @worker.enabled = false
-        end
-
-        def started!
-          return if !@enabled || forked?
-
-          res = @emitter.request(:'app-started')
-
-          if res.not_found? # Telemetry is only supported by agent versions 7.34 and up
-            Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.')
-            disable!
-            @unsupported = true # Prevent telemetry from getting re-enabled
-          end
-
-          res
-        end
-
-        def emit_closing!
-          return if !@enabled || forked?
-
-          @emitter.request(:'app-closing')
-        end
-
-        def stop!
-          return if @stopped
-
-          @worker.stop(true, 0)
-          @stopped = true
-        end
-
-        def integrations_change!
-          return if !@enabled || forked?
-
-          @emitter.request(:'app-integrations-change')
-        end
-
-        private
-
-        def heartbeat!
-          return if !@enabled || forked?
-
-          @emitter.request(:'app-heartbeat')
-        end
-      end
-    end
-  end
-end

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

@@ -1,234 +0,0 @@
-# frozen_string_literal: true
-
-# typed: true
-
-require 'etc'
-
-require_relative '../configuration/agent_settings_resolver'
-require_relative '../environment/ext'
-require_relative '../environment/platform'
-require_relative 'v1/application'
-require_relative 'v1/dependency'
-require_relative 'v1/host'
-require_relative 'v1/integration'
-require_relative 'v1/product'
-require_relative '../../../ddtrace/transport/ext'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Module defining methods for collecting metadata for telemetry
-      # rubocop:disable Metrics/ModuleLength
-      module Collector
-        include Datadog::Core::Configuration
-
-        # 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
-          configurations = {
-            DD_AGENT_HOST: Datadog.configuration.agent.host,
-            DD_AGENT_TRANSPORT: agent_transport,
-            DD_TRACE_SAMPLE_RATE: format_configuration_value(Datadog.configuration.tracing.sampling.default_rate),
-          }
-          compact_hash(configurations)
-        end
-
-        # Forms a telemetry app-started dependencies object
-        def dependencies
-          Gem.loaded_specs.collect do |name, loaded_gem|
-            Datadog::Core::Telemetry::V1::Dependency.new(
-              name: name, version: loaded_gem.version.to_s, hash: loaded_gem.hash.to_s
-            )
-          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 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 = [
-          'ci.enabled',
-          'logger.level',
-          'profiling.advanced.code_provenance_enabled',
-          'profiling.advanced.endpoint.collection.enabled',
-          'profiling.enabled',
-          'runtime_metrics.enabled',
-          'tracing.analytics.enabled',
-          'tracing.distributed_tracing.propagation_inject_style',
-          'tracing.distributed_tracing.propagation_extract_style',
-          'tracing.enabled',
-          'tracing.log_injection',
-          'tracing.partial_flush.enabled',
-          'tracing.partial_flush.min_spans_threshold',
-          'tracing.priority_sampling',
-          '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')
-          compact_hash(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
-
-        # Manual implementation of hash.compact used because it is unsupported by older Ruby versions (<2.4)
-        def compact_hash(hash)
-          hash.delete_if { |_k, v| v.nil? }
-        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.tracer_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::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.to_s
-          end
-        end
-      end
-      # rubocop:enable Metrics/ModuleLength
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# typed: false
-
-require_relative '../worker'
-require_relative '../workers/polling'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Periodically (every DEFAULT_INTERVAL_SECONDS) sends a heartbeat event to the telemetry API.
-      class Heartbeat < Core::Worker
-        include Core::Workers::Polling
-
-        DEFAULT_INTERVAL_SECONDS = 60
-
-        def initialize(enabled: true, interval: DEFAULT_INTERVAL_SECONDS, &block)
-          # Workers::Polling settings
-          self.enabled = enabled
-          # Workers::IntervalLoop settings
-          self.loop_base_interval = interval
-          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
-          super(&block)
-          start
-        end
-
-        def loop_wait_before_first_iteration?
-          true
-        end
-
-        private
-
-        def start
-          perform
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes payload for telemetry V1 API app-integrations-change event
-        class AppEvent
-          include Kernel
-
-          attr_reader \
-            :additional_payload,
-            :configuration,
-            :dependencies,
-            :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 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, integrations: nil)
-            @additional_payload = additional_payload
-            @configuration = configuration
-            @dependencies = dependencies
-            @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[: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,86 +0,0 @@
-module Datadog
-  module Core
-    module Telemetry
-      module V1
-        # Describes attributes for application environment object
-        class Application
-          ERROR_NIL_LANGUAGE_NAME_MESSAGE = ':language_name must not be nil'.freeze
-          ERROR_NIL_LANGUAGE_VERSION_MESSAGE = ':language_version must not be nil'.freeze
-          ERROR_NIL_SERVICE_NAME_MESSAGE = ':service_name must not be nil'.freeze
-          ERROR_NIL_TRACER_VERSION_MESSAGE = ':tracer_version must not be nil'.freeze
-
-          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
-            {
-              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
-            }
-          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,25 +0,0 @@
-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'.freeze
-
-          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