datadog 2.0.0.beta1

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+require_relative 'http/transport'
+require_relative '../utils/sequence'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Class that emits telemetry events
+      class Emitter
+        attr_reader :http_transport
+
+        extend Core::Utils::Forking
+
+        # @param sequence [Datadog::Core::Utils::Sequence] Sequence object that stores and increments a counter
+        # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
+        #   telemetry requests via the agent
+        def initialize(http_transport: Datadog::Core::Telemetry::Http::Transport.new)
+          @http_transport = http_transport
+        end
+
+        # Retrieves and emits a TelemetryRequest object based on the request type specified
+        # @param request_type [String] the type of telemetry request to collect data for
+        # @param data [Object] arbitrary object to be passed to the respective `request_type` handler
+        def request(request_type, data: nil)
+          begin
+            request = Datadog::Core::Telemetry::Event.new.telemetry_request(
+              request_type: request_type,
+              seq_id: self.class.sequence.next,
+              data: data,
+            ).to_h
+            @http_transport.request(request_type: request_type.to_s, payload: request.to_json)
+          rescue StandardError => e
+            Datadog.logger.debug("Unable to send telemetry request for event `#{request_type}`: #{e}")
+            Telemetry::Http::InternalErrorResponse.new(e)
+          end
+        end
+
+        # Initializes a Sequence object to track seq_id if not already initialized; else returns stored
+        # Sequence object
+        def self.sequence
+          after_fork! { @sequence = Datadog::Core::Utils::Sequence.new(1) }
+          @sequence ||= Datadog::Core::Utils::Sequence.new(1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'collector'
+require_relative 'v1/app_event'
+require_relative 'v1/telemetry_request'
+require_relative 'v2/app_client_configuration_change'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Class defining methods to construct a Telemetry event
+      class Event
+        include Telemetry::Collector
+
+        API_VERSION = 'v1'
+
+        attr_reader \
+          :api_version
+
+        def initialize
+          @api_version = API_VERSION
+        end
+
+        # Forms a TelemetryRequest object based on the event request_type
+        # @param request_type [String] the type of telemetry request to collect data for
+        # @param seq_id [Integer] the ID of the request; incremented each time a telemetry request is sent to the API
+        # @param data [Object] arbitrary object to be passed to the respective `request_type` handler
+        def telemetry_request(request_type:, seq_id:, data: nil)
+          Telemetry::V1::TelemetryRequest.new(
+            api_version: @api_version,
+            application: application,
+            host: host,
+            payload: payload(request_type, data),
+            request_type: request_type,
+            runtime_id: runtime_id,
+            seq_id: seq_id,
+            tracer_time: tracer_time,
+          )
+        end
+
+        private
+
+        def payload(request_type, data)
+          case request_type
+          when :'app-started'
+            app_started
+          when :'app-closing', :'app-heartbeat'
+            {}
+          when :'app-integrations-change'
+            app_integrations_change
+          when 'app-client-configuration-change'
+            app_client_configuration_change(data)
+          else
+            raise ArgumentError, "Request type invalid, received request_type: #{@request_type}"
+          end
+        end
+
+        def app_started
+          Telemetry::V1::AppEvent.new(
+            dependencies: dependencies,
+            integrations: integrations,
+            configuration: configurations,
+            additional_payload: additional_payload,
+            install_signature: install_signature
+          )
+        end
+
+        def app_integrations_change
+          Telemetry::V1::AppEvent.new(integrations: integrations)
+        end
+
+        # DEV: During the transition from V1 to V2, the backend accepts many V2
+        # DEV: payloads through the V1 transport protocol.
+        # DEV: The `app-client-configuration-change` payload is one of them.
+        # DEV: Once V2 is fully implemented, `Telemetry::V2::AppClientConfigurationChange`
+        # DEV: should be reusable without major modifications.
+        def app_client_configuration_change(data)
+          Telemetry::V2::AppClientConfigurationChange.new(data[:changes], origin: data[:origin])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Ext
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
+        ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
+        ENV_INSTALL_ID = 'DD_INSTRUMENTATION_INSTALL_ID'
+        ENV_INSTALL_TYPE = 'DD_INSTRUMENTATION_INSTALL_TYPE'
+        ENV_INSTALL_TIME = 'DD_INSTRUMENTATION_INSTALL_TIME'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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
+
+        def initialize(heartbeat_interval_seconds:, enabled: true, &block)
+          # Workers::Polling settings
+          self.enabled = enabled
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = heartbeat_interval_seconds
+          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/http/adapters/net.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative '../response'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Adapters
+          # Class defining methods to make http requests via NET
+          class Net
+            attr_reader \
+              :hostname,
+              :port,
+              :timeout,
+              :ssl
+
+            DEFAULT_TIMEOUT = 30
+
+            def initialize(hostname:, port: nil, timeout: DEFAULT_TIMEOUT, ssl: true)
+              @hostname = hostname
+              @port = port
+              @timeout = timeout
+              @ssl = ssl.nil? ? true : ssl
+            end
+
+            def open(&block)
+              req = ::Net::HTTP.new(@hostname, @port)
+
+              req.use_ssl = @ssl
+              req.open_timeout = req.read_timeout = @timeout
+
+              req.start(&block)
+            end
+
+            def post(env)
+              begin
+                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post.body = env.body
+
+                http_response = open do |http|
+                  http.request(post)
+                end
+
+                Response.new(http_response)
+              rescue StandardError => e
+                Datadog.logger.debug("Unable to send telemetry event to agent: #{e}")
+                Telemetry::Http::InternalErrorResponse.new(e)
+              end
+            end
+
+            # Data structure for an HTTP Response
+            class Response
+              include Datadog::Core::Telemetry::Http::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/telemetry/http/env.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        # Data structure for an HTTP request
+        class Env
+          attr_accessor :path, :body
+
+          attr_writer :headers
+
+          def headers
+            @headers ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/http/ext.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Ext
+          HEADER_DD_API_KEY = 'DD-API-KEY'
+          HEADER_CONTENT_TYPE = 'Content-Type'
+          HEADER_CONTENT_LENGTH = 'Content-Length'
+          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'
+          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'
+
+          CONTENT_TYPE_APPLICATION_JSON = 'application/json'
+          API_VERSION = 'v1'
+
+          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/http/response.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        # Module for base HTTP response
+        module Response
+          def payload
+            nil
+          end
+
+          def ok?
+            nil
+          end
+
+          def unsupported?
+            nil
+          end
+
+          def not_found?
+            nil
+          end
+
+          def client_error?
+            nil
+          end
+
+          def server_error?
+            nil
+          end
+
+          def internal_error?
+            nil
+          end
+
+          def inspect
+            "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
+            "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
+            "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
+            "payload:#{payload}"
+          end
+        end
+
+        # A generic error response for internal errors
+        class InternalErrorResponse
+          include Response
+
+          attr_reader :error
+
+          def initialize(error)
+            @error = error
+          end
+
+          def internal_error?
+            true
+          end
+
+          def inspect
+            "#{super}, error_type:#{error.class} error:#{error}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../../transport/ext'
+require_relative 'env'
+require_relative 'ext'
+require_relative 'adapters/net'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        # Class to send telemetry data to Telemetry API
+        # Currently only supports the HTTP protocol.
+        class Transport
+          attr_reader \
+            :host,
+            :port,
+            :ssl,
+            :path
+
+          def initialize
+            agent_settings = Configuration::AgentSettingsResolver.call(Datadog.configuration)
+            @host = agent_settings.hostname
+            @port = agent_settings.port
+            @ssl = false
+            @path = Http::Ext::AGENT_ENDPOINT
+          end
+
+          def request(request_type:, payload:)
+            env = Http::Env.new
+            env.path = @path
+            env.body = payload
+            env.headers = headers(request_type: request_type)
+            adapter.post(env)
+          end
+
+          private
+
+          def headers(request_type:, api_version: Http::Ext::API_VERSION)
+            {
+              Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
+              Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
+              Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
+              Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,
+            }
+          end
+
+          def adapter
+            @adapter ||= Http::Adapters::Net.new(hostname: @host, port: @port, ssl: @ssl)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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