ddtrace 1.1.0 → 1.9.0

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

@@ -0,0 +1,71 @@
+# typed: true
+
+require_relative 'collector'
+require_relative 'v1/app_event'
+require_relative 'v1/telemetry_request'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Class defining methods to construct a Telemetry event
+      class Event
+        include Kernel
+
+        include Telemetry::Collector
+
+        API_VERSION = 'v1'.freeze
+
+        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
+        def telemetry_request(request_type:, seq_id:)
+          Telemetry::V1::TelemetryRequest.new(
+            api_version: @api_version,
+            application: application,
+            host: host,
+            payload: payload(request_type),
+            request_type: request_type,
+            runtime_id: runtime_id,
+            seq_id: seq_id,
+            tracer_time: tracer_time,
+          )
+        end
+
+        private
+
+        def payload(request_type)
+          case request_type
+          when :'app-started'
+            app_started
+          when :'app-closing', :'app-heartbeat'
+            {}
+          when :'app-integrations-change'
+            app_integrations_change
+          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
+          )
+        end
+
+        def app_integrations_change
+          Telemetry::V1::AppEvent.new(integrations: integrations)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Ext
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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/http/adapters/net.rb

@@ -0,0 +1,113 @@
+# typed: 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 @@
+# typed: 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,20 @@
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Ext
+          HEADER_DD_API_KEY = 'DD-API-KEY'.freeze
+          HEADER_CONTENT_TYPE = 'Content-Type'.freeze
+          HEADER_CONTENT_LENGTH = 'Content-Length'.freeze
+          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'.freeze
+          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'.freeze
+
+          CONTENT_TYPE_APPLICATION_JSON = 'application/json'.freeze
+          API_VERSION = 'v1'.freeze
+
+          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        # Module for base HTTP response
+        module Response
+          include Kernel
+
+          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,53 @@
+# typed: true
+
+require_relative '../../configuration/settings'
+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
+        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)
+            {
+              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,52 @@
+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

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

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

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

@@ -0,0 +1,36 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for dependency object
+        class Dependency
+          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'.freeze
+
+          attr_reader \
+            :hash,
+            :name,
+            :version
+
+          # @param name [String] Module name
+          # @param version [String] Version of resolved module
+          # @param hash [String] Dependency hash
+          def initialize(name:, version: nil, hash: nil)
+            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
+
+            @hash = hash
+            @name = name
+            @version = version
+          end
+
+          def to_h
+            {
+              hash: @hash,
+              name: @name,
+              version: @version
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for host object
+        class Host
+          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
+            {
+              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
+        end
+      end
+    end
+  end
+end