ddtrace 1.12.1 → 1.18.0

data/lib/datadog/ci/test.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-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 @@
-# frozen_string_literal: true
-
-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 @@
-# frozen_string_literal: true
-
-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 @@
-# frozen_string_literal: 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 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Configuration
-      class OptionSet < Hash
-      end
-    end
-  end
-end

data/lib/datadog/core/transport/config.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ddtrace/transport/request'
-require_relative '../../../ddtrace/transport/parcel'
-
-module Datadog
-  module Core
-    module Transport
-      module Config
-        # Data transfer object for encoded traces
-        class EncodedParcel
-          include Datadog::Transport::Parcel
-
-          def count
-            data.length
-          end
-        end
-
-        # Config request
-        class Request < Datadog::Transport::Request
-        end
-
-        # Config response
-        module Response
-          attr_reader :roots, :targets, :target_files, :client_configs
-
-          def empty?
-            @empty
-          end
-        end
-
-        # Config transport
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
-
-          def initialize(apis, default_api)
-            @apis = apis
-
-            @client = HTTP::Client.new(current_api)
-          end
-
-          ##### there is only one transport! it's negotiation!
-          def send_config(payload)
-            json = JSON.dump(payload)
-            parcel = EncodedParcel.new(json)
-            request = Request.new(parcel)
-
-            @client.send_config_payload(request)
-          end
-
-          def current_api
-            @apis[HTTP::API::V7]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/transport/http/api.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../encoding'
-
-require_relative '../../../../ddtrace/transport/http/api/map'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/traces includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/spec'
-require_relative 'api/spec'
-
-# TODO: only needed for Negotiation::API::Endpoint
-require_relative 'negotiation'
-
-# TODO: only needed for Config::API::Endpoint
-require_relative 'config'
-
-module Datadog
-  module Core
-    module Transport
-      module HTTP
-        # Namespace for API components
-        module API
-          # Default API versions
-          ROOT = 'root'
-          V7 = 'v0.7'
-
-          module_function
-
-          def defaults
-            Datadog::Transport::HTTP::API::Map[
-              ROOT => Spec.new do |s|
-                s.info = Negotiation::API::Endpoint.new(
-                  '/info',
-                )
-              end,
-              V7 => Spec.new do |s|
-                s.config = Config::API::Endpoint.new(
-                  '/v0.7/config',
-                  Core::Encoding::JSONEncoder,
-                )
-              end,
-            ]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/transport/http/client.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../../ddtrace/transport/http/env'
-
-# TODO: Decouple transport/http/client
-#
-# The standard one does `include Transport::HTTP::Statistics` and performs
-# stats updates, which may or may not be desirable in general.
-
-module Datadog
-  module Core
-    module Transport
-      module HTTP
-        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
-        class Client
-          attr_reader :api
-
-          def initialize(api)
-            @api = api
-          end
-
-          def send_request(request, &block)
-            # Build request into env
-            env = build_env(request)
-
-            # Get responses from API
-            yield(api, env)
-          rescue StandardError => e
-            message =
-              "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
-              "Location: #{Array(e.backtrace).first}"
-
-            Datadog.logger.error(message)
-
-            Datadog::Transport::InternalErrorResponse.new(e)
-          end
-
-          def build_env(request)
-            Datadog::Transport::HTTP::Env.new(request)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/transport/http/config.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'base64'
-
-require_relative '../config'
-require_relative 'client'
-require_relative '../../../../ddtrace/transport/http/response'
-require_relative '../../../../ddtrace/transport/http/api/endpoint'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/spec'
-require_relative 'api/spec'
-
-module Datadog
-  module Core
-    module Transport
-      module HTTP
-        # HTTP transport behavior for remote configuration
-        module Config
-          # Response from HTTP transport for remote configuration
-          class Response
-            include Datadog::Transport::HTTP::Response
-            include Core::Transport::Config::Response
-
-            def initialize(http_response, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-              super(http_response)
-
-              begin
-                payload = JSON.parse(http_response.payload, symbolize_names: true)
-              rescue JSON::ParserError => e
-                raise ParseError.new(:roots, e)
-              end
-
-              raise TypeError.new(Hash, payload) unless payload.is_a?(Hash)
-
-              @empty = true if payload.empty?
-
-              # TODO: these fallbacks should be improved
-              roots = payload[:roots] || []
-              targets = payload[:targets] || Base64.encode64('{}').chomp
-              target_files = payload[:target_files] || []
-              client_configs = payload[:client_configs] || []
-
-              raise TypeError.new(Array, roots) unless roots.is_a?(Array)
-
-              @roots = roots.map do |root|
-                raise TypeError.new(String, root) unless root.is_a?(String)
-
-                decoded = begin
-                  Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
-                rescue ArgumentError
-                  raise DecodeError.new(:roots, root)
-                end
-
-                parsed = begin
-                  JSON.parse(decoded)
-                rescue JSON::ParserError
-                  raise ParseError.new(:roots, decoded)
-                end
-
-                # TODO: perform more processing to validate content. til then, no freeze
-
-                parsed
-              end
-
-              raise TypeError.new(String, targets) unless targets.is_a?(String)
-
-              @targets = begin
-                decoded = begin
-                  Base64.strict_decode64(targets)
-                rescue ArgumentError
-                  raise DecodeError.new(:targets, targets)
-                end
-
-                parsed = begin
-                  JSON.parse(decoded) # TODO: unprocessed, don't symbolize_names
-                rescue JSON::ParserError
-                  raise ParseError.new(:targets, decoded)
-                end
-
-                # TODO: perform more processing to validate content. til then, no freeze
-
-                parsed
-              end
-
-              raise TypeError.new(Array, target_files) unless target_files.is_a?(Array)
-
-              @target_files = target_files.map do |h|
-                raise TypeError.new(Hash, h) unless h.is_a?(Hash)
-                raise KeyError.new(:raw) unless h.key?(:raw) # rubocop:disable Style/RaiseArgs
-                raise KeyError.new(:path) unless h.key?(:path) # rubocop:disable Style/RaiseArgs
-
-                raw = h[:raw]
-
-                raise TypeError.new(String, raw) unless raw.is_a?(String)
-
-                content = begin
-                  Base64.strict_decode64(raw)
-                rescue ArgumentError
-                  raise DecodeError.new(:target_files, raw)
-                end
-
-                {
-                  path: h[:path].freeze,
-                  content: StringIO.new(content.freeze),
-                }
-              end.freeze
-
-              @client_configs = client_configs.map do |s|
-                raise TypeError.new(String, s) unless s.is_a?(String)
-
-                s.freeze
-              end.freeze
-            end
-
-            # When an expected key is missing
-            class KeyError < StandardError
-              def initialize(key)
-                message = "key not found: #{key.inspect}"
-
-                super(message)
-              end
-            end
-
-            # When an expected value type is incorrect
-            class TypeError < StandardError
-              def initialize(type, value)
-                message = "not a #{type}: #{value.inspect}"
-
-                super(message)
-              end
-            end
-
-            # When value decoding fails
-            class DecodeError < StandardError
-              def initialize(key, value)
-                message = "could not decode key #{key.inspect}: #{value.inspect}"
-
-                super(message)
-              end
-            end
-
-            # When value parsing fails
-            class ParseError < StandardError
-              def initialize(key, value)
-                message = "could not parse key #{key.inspect}: #{value.inspect}"
-
-                super(message)
-              end
-            end
-          end
-
-          # Extensions for HTTP client
-          module Client
-            def send_config_payload(request)
-              send_request(request) do |api, env|
-                api.send_config(env)
-              end
-            end
-          end
-
-          module API
-            # Extensions for HTTP API Spec
-            module Spec
-              attr_reader :config
-
-              def config=(endpoint)
-                @config = endpoint
-              end
-
-              def send_config(env, &block)
-                raise NoConfigEndpointDefinedError, self if config.nil?
-
-                config.call(env, &block)
-              end
-
-              # Raised when traces sent but no traces endpoint is defined
-              class NoConfigEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super()
-
-                  @spec = spec
-                end
-
-                def message
-                  'No config endpoint is defined for API specification!'
-                end
-              end
-            end
-
-            # Extensions for HTTP API Instance
-            module Instance
-              def send_config(env)
-                raise ConfigNotSupportedError, spec unless spec.is_a?(Config::API::Spec)
-
-                spec.send_config(env) do |request_env|
-                  call(request_env)
-                end
-              end
-
-              # Raised when traces sent to API that does not support traces
-              class ConfigNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super()
-
-                  @spec = spec
-                end
-
-                def message
-                  'Config not supported for this API!'
-                end
-              end
-            end
-
-            # Endpoint for remote configuration
-            class Endpoint < Datadog::Transport::HTTP::API::Endpoint
-              HEADER_CONTENT_TYPE = 'Content-Type'
-
-              attr_reader :encoder
-
-              def initialize(path, encoder)
-                super(:post, path)
-                @encoder = encoder
-              end
-
-              def call(env, &block)
-                # Encode body & type
-                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
-                env.body = env.request.parcel.data
-
-                # Query for response
-                http_response = super(env, &block)
-
-                response_options = {}
-
-                # Build and return a response
-                Config::Response.new(http_response, response_options)
-              end
-            end
-          end
-
-          # Add remote configuration behavior to transport components
-          ###### overrides send_payload! which calls send_<endpoint>! kills any other possible endpoint!
-          HTTP::Client.include(Config::Client)
-          HTTP::API::Spec.include(Config::API::Spec)
-          HTTP::API::Instance.include(Config::API::Instance)
-        end
-      end
-    end
-  end
-end