datadog 2.0.0.beta1

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

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

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

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

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

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/hash'
+
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for telemetry API request
+        class TelemetryRequest
+          using Core::Utils::Hash::Refinement
+
+          ERROR_NIL_API_VERSION_MESSAGE = ':api_version must not be nil'
+          ERROR_NIL_APPLICATION_MESSAGE = ':application must not be nil'
+          ERROR_NIL_HOST_MESSAGE = ':host must not be nil'
+          ERROR_NIL_PAYLOAD_MESSAGE = ':payload must not be nil'
+          ERROR_NIL_REQUEST_TYPE_MESSAGE = ':request_type must not be nil'
+          ERROR_NIL_RUNTIME_ID_MESSAGE = ':runtime_id must not be nil'
+          ERROR_NIL_SEQ_ID_MESSAGE = ':seq_id must not be nil'
+          ERROR_NIL_TRACER_TIME_MESSAGE = ':tracer_time must not be nil'
+
+          attr_reader \
+            :api_version,
+            :application,
+            :debug,
+            :host,
+            :payload,
+            :request_type,
+            :runtime_id,
+            :seq_id,
+            :session_id,
+            :tracer_time
+
+          # @param api_version [String] Requested API version, `v1`
+          # @param application [Telemetry::V1::Application] Object that contains information about the environment of the
+          #   application
+          # @param host [Telemetry::V1::Host] Object that holds host related information
+          # @param payload [Telemetry::V1::AppEvent] The payload of the request, type impacted by :request_type
+          # @param request_type [String] Requested API function impacting the Payload type, `app-started`
+          # @param runtime_id [String] V4 UUID that represents a tracer session
+          # @param seq_id [Integer] Counter that should be auto incremented every time an API call is being made
+          # @param tracer_time [Integer] Unix timestamp (in seconds) of when the message is being sent
+          # @param debug [Boolean] Flag that enables payload debug mode
+          # @param session_id [String] V4 UUID that represents the session of the top level tracer process, often same\
+          #   as runtime_id
+          def initialize(
+            api_version:, application:, host:, payload:, request_type:, runtime_id:, seq_id:, tracer_time:,
+            debug: nil, session_id: nil
+          )
+            validate(
+              api_version: api_version,
+              application: application,
+              host: host,
+              payload: payload,
+              request_type: request_type,
+              runtime_id: runtime_id,
+              seq_id: seq_id,
+              tracer_time: tracer_time
+            )
+            @api_version = api_version
+            @application = application
+            @debug = debug
+            @host = host
+            @payload = payload
+            @request_type = request_type
+            @runtime_id = runtime_id
+            @seq_id = seq_id
+            @session_id = session_id
+            @tracer_time = tracer_time
+          end
+
+          def to_h
+            hash = {
+              api_version: @api_version,
+              application: @application.to_h,
+              debug: @debug,
+              host: @host.to_h,
+              payload: @payload.to_h,
+              request_type: @request_type,
+              runtime_id: @runtime_id,
+              seq_id: @seq_id,
+              session_id: @session_id,
+              tracer_time: @tracer_time
+            }
+            hash.compact!
+            hash
+          end
+
+          private
+
+          # Validates all required arguments passed to the class on initialization are not nil
+          #
+          # @!visibility private
+          def validate(api_version:, application:, host:, payload:, request_type:, runtime_id:, seq_id:, tracer_time:)
+            raise ArgumentError, ERROR_NIL_API_VERSION_MESSAGE if api_version.nil?
+            raise ArgumentError, ERROR_NIL_APPLICATION_MESSAGE if application.nil?
+            raise ArgumentError, ERROR_NIL_HOST_MESSAGE if host.nil?
+            raise ArgumentError, ERROR_NIL_PAYLOAD_MESSAGE if payload.nil?
+            raise ArgumentError, ERROR_NIL_REQUEST_TYPE_MESSAGE if request_type.nil?
+            raise ArgumentError, ERROR_NIL_RUNTIME_ID_MESSAGE if runtime_id.nil?
+            raise ArgumentError, ERROR_NIL_SEQ_ID_MESSAGE if seq_id.nil?
+            raise ArgumentError, ERROR_NIL_TRACER_TIME_MESSAGE if tracer_time.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/v2/app_client_configuration_change.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'request'
+
+module Datadog
+  module Core
+    module Telemetry
+      module V2
+        # Telemetry 'app-client-configuration-change' event.
+        # This request should contain client library configuration that have changes since the app-started event.
+        class AppClientConfigurationChange < Request
+          def initialize(configuration_changes, origin: 'unknown')
+            super('app-client-configuration-change')
+
+            @configuration_changes = configuration_changes
+            @origin = origin
+          end
+
+          # @see [Request#to_h]
+          def to_h
+            super.merge(payload: payload)
+          end
+
+          private
+
+          def payload
+            {
+              configuration: @configuration_changes.map do |name, value|
+                {
+                  name: name,
+                  value: value,
+                  origin: @origin,
+                }
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/v2/request.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module V2
+        # Base request object for Telemetry V2.
+        #
+        # `#to_h` is the main API, which returns a Ruby
+        # Hash that will be serialized as JSON.
+        class Request
+          # @param [String] request_type the Telemetry request type, which dictates how the Hash payload should be processed
+          def initialize(request_type)
+            @request_type = request_type
+          end
+
+          # Converts this request to a Hash that will
+          # be serialized as JSON.
+          # @return [Hash]
+          def to_h
+            {
+              request_type: @request_type
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../configuration/ext'
+module Datadog
+  module Core
+    module Transport
+      # @public_api
+      module Ext
+        module HTTP
+          HEADER_CONTAINER_ID = 'Datadog-Container-ID'
+          HEADER_DD_API_KEY = 'DD-API-KEY'
+          # Tells agent that `_dd.top_level` metrics have been set by the tracer.
+          # The agent will not calculate top-level spans but instead trust the tracer tagging.
+          #
+          # This prevents partially flushed traces being mistakenly marked as top-level.
+          #
+          # Setting this header to any non-empty value enables this feature.
+          HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'
+          HEADER_META_LANG = 'Datadog-Meta-Lang'
+          HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'
+          HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'
+          # Use for distinguishing between CRuby, JRuby, and TruffleRuby.
+          HEADER_META_LANG_INTERPRETER_VENDOR = 'Datadog-Meta-Lang-Interpreter-Vendor'
+          HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'
+
+          # Header that prevents the Net::HTTP integration from tracing internal trace requests.
+          # Set it to any value to skip tracing.
+          HEADER_DD_INTERNAL_UNTRACED_REQUEST = 'DD-Internal-Untraced-Request'
+        end
+
+        module Test
+          ADAPTER = :test
+        end
+
+        module UnixSocket
+          ADAPTER = Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
+          DEFAULT_PATH = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_PATH
+          DEFAULT_TIMEOUT_SECONDS = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_TIMEOUT_SECONDS
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/adapters/net.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+require_relative '../../../../core/vendor/multipart-post/net/http/post/multipart'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # Adapter for Net::HTTP
+          class Net
+            attr_reader \
+              :hostname,
+              :port,
+              :timeout,
+              :ssl
+
+            def initialize(agent_settings)
+              @hostname = agent_settings.hostname
+              @port = agent_settings.port
+              @timeout = agent_settings.timeout_seconds
+              @ssl = agent_settings.ssl
+            end
+
+            def self.build(agent_settings)
+              new(agent_settings)
+            end
+
+            def open(&block)
+              # DEV Initializing +Net::HTTP+ directly help us avoid expensive
+              # options processing done in +Net::HTTP.start+:
+              # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
+              req = ::Net::HTTP.new(hostname, port, nil)
+
+              req.use_ssl = ssl
+              req.open_timeout = req.read_timeout = timeout
+
+              req.start(&block)
+            end
+
+            def call(env)
+              if respond_to?(env.verb)
+                send(env.verb, env)
+              else
+                raise UnknownHTTPMethod, env
+              end
+            end
+
+            def get(env)
+              get = ::Net::HTTP::Get.new(env.path, env.headers)
+
+              # Connect and send the request
+              http_response = open do |http|
+                http.request(get)
+              end
+
+              # Build and return response
+              Response.new(http_response)
+            end
+
+            def post(env)
+              post = nil
+
+              if env.form.nil? || env.form.empty?
+                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post.body = env.body
+              else
+                post = ::Datadog::Core::Vendor::Net::HTTP::Post::Multipart.new(
+                  env.path,
+                  env.form,
+                  env.headers
+                )
+              end
+
+              # Connect and send the request
+              http_response = open do |http|
+                http.request(post)
+              end
+
+              # Build and return response
+              Response.new(http_response)
+            end
+
+            def url
+              "http://#{hostname}:#{port}?timeout=#{timeout}"
+            end
+
+            # Raised when called with an unknown HTTP method
+            class UnknownHTTPMethod < StandardError
+              attr_reader :verb
+
+              def initialize(verb)
+                super("No matching Net::HTTP function for '#{verb}'!")
+              end
+            end
+
+            # A wrapped Net::HTTP response that implements the Transport::Response interface
+            class Response
+              include Datadog::Core::Transport::Response
+
+              attr_reader :http_response
+
+              def initialize(http_response)
+                @http_response = http_response
+              end
+
+              def payload
+                return super if http_response.nil?
+
+                http_response.body
+              end
+
+              def code
+                return super if http_response.nil?
+
+                http_response.code.to_i
+              end
+
+              def ok?
+                return super if http_response.nil?
+
+                code.between?(200, 299)
+              end
+
+              def unsupported?
+                return super if http_response.nil?
+
+                code == 415
+              end
+
+              def not_found?
+                return super if http_response.nil?
+
+                code == 404
+              end
+
+              def client_error?
+                return super if http_response.nil?
+
+                code.between?(400, 499)
+              end
+
+              def server_error?
+                return super if http_response.nil?
+
+                code.between?(500, 599)
+              end
+
+              def inspect
+                "#{super}, http_response:#{http_response}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/adapters/registry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # List of available adapters
+          class Registry
+            def initialize
+              @adapters = {}
+            end
+
+            def get(name)
+              @adapters[name]
+            end
+
+            def set(klass, name = nil)
+              name ||= klass.to_s
+              return if name.nil?
+
+              @adapters[name] = klass
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/adapters/test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # Adapter for testing
+          class Test
+            attr_reader \
+              :buffer,
+              :status
+
+            # @param buffer [Array] an optional array that will capture all spans sent to this adapter, defaults to +nil+
+            # @deprecated Positional parameters are deprecated. Use named parameters instead.
+            def initialize(buffer = nil, **options)
+              @buffer = buffer || options[:buffer]
+              @mutex = Mutex.new
+              @status = 200
+            end
+
+            def call(env)
+              add_request(env)
+              Response.new(status)
+            end
+
+            def buffer?
+              !@buffer.nil?
+            end
+
+            def add_request(env)
+              @mutex.synchronize { buffer << env } if buffer?
+            end
+
+            def set_status!(status)
+              @status = status
+            end
+
+            def url; end
+
+            # Response for test adapter
+            class Response
+              include Datadog::Core::Transport::Response
+
+              attr_reader \
+                :body,
+                :code
+
+              def initialize(code, body = nil)
+                @code = code
+                @body = body
+              end
+
+              def payload
+                @body
+              end
+
+              def ok?
+                code.between?(200, 299)
+              end
+
+              def unsupported?
+                code == 415
+              end
+
+              def not_found?
+                code == 404
+              end
+
+              def client_error?
+                code.between?(400, 499)
+              end
+
+              def server_error?
+                code.between?(500, 599)
+              end
+
+              def inspect
+                "#{super}, code:#{code}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end