ddtrace 0.54.2 → 1.10.1

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

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

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

@@ -0,0 +1,58 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for integration object
+        class Integration
+          ERROR_NIL_ENABLED_MESSAGE = ':enabled must not be nil'.freeze
+          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'.freeze
+
+          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
+            {
+              auto_enabled: @auto_enabled,
+              compatible: @compatible,
+              enabled: @enabled,
+              error: @error,
+              name: @name,
+              version: @version
+            }
+          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,28 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for products object
+        class Product
+          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
+            {
+              appsec: @appsec,
+              profiler: @profiler
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for telemetry API request
+        class TelemetryRequest
+          ERROR_NIL_API_VERSION_MESSAGE = ':api_version must not be nil'.freeze
+          ERROR_NIL_APPLICATION_MESSAGE = ':application must not be nil'.freeze
+          ERROR_NIL_HOST_MESSAGE = ':host must not be nil'.freeze
+          ERROR_NIL_PAYLOAD_MESSAGE = ':payload must not be nil'.freeze
+          ERROR_NIL_REQUEST_TYPE_MESSAGE = ':request_type must not be nil'.freeze
+          ERROR_NIL_RUNTIME_ID_MESSAGE = ':runtime_id must not be nil'.freeze
+          ERROR_NIL_SEQ_ID_MESSAGE = ':seq_id must not be nil'.freeze
+          ERROR_NIL_TRACER_TIME_MESSAGE = ':tracer_time must not be nil'.freeze
+
+          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
+            {
+              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
+            }
+          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/utils/compression.rb

@@ -0,0 +1,34 @@
+require 'stringio'
+require 'zlib'
+
+module Datadog
+  module Core
+    module Utils
+      # Compression/decompression utility functions.
+      #
+      # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+      module Compression
+        module_function
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gzip(string, level: nil, strategy: nil)
+          sio = StringIO.new
+          sio.binmode
+          gz = Zlib::GzipWriter.new(sio, level, strategy)
+          gz.write(string)
+          gz.close
+          sio.string
+        end
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+          sio = StringIO.new(string)
+          gz = Zlib::GzipReader.new(sio, encoding: encoding)
+          gz.read
+        ensure
+          gz && gz.close
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/forking.rb

@@ -0,0 +1,61 @@
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for managing forking behavior
+      module Forking
+        def self.included(base)
+          base.prepend(ClassExtensions) if base.is_a?(Class)
+        end
+
+        def self.extended(base)
+          # Explicitly update PID here because there's a case where
+          # the code path that lazily updates the PID may not be exercised
+          # until after a fork occurs, thus causing the event to be missed.
+          # By eagerly setting this, we avoid this scenario.
+          base.update_fork_pid!
+        end
+
+        def after_fork!
+          if forked?
+            yield
+            update_fork_pid!
+            true
+          else
+            false
+          end
+        end
+
+        def forked?
+          Process.pid != fork_pid
+        end
+
+        def update_fork_pid!
+          @fork_pid = Process.pid
+        end
+
+        def fork_pid
+          @fork_pid ||= Process.pid
+        end
+
+        # Adds additional functionality for Classes that implement Forking
+        module ClassExtensions
+          # Addresses an edge case where forking before invoking #update_fork_pid! on the
+          # object will cause forking to not be detected in the fork when it should have.
+          #
+          # This wrapper prevents this by initializing the fork PID when the object is created.
+          if RUBY_VERSION >= '3'
+            def initialize(*args, **kwargs, &block)
+              super(*args, **kwargs, &block)
+              update_fork_pid!
+            end
+          else
+            def initialize(*args, &block)
+              super(*args, &block)
+              update_fork_pid!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/network.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require_relative '../vendor/ipaddr'
+
+module Datadog
+  module Core
+    module Utils
+      # Common Network utility functions.
+      module Network
+        DEFAULT_IP_HEADERS_NAMES = %w[
+          x-forwarded-for
+          x-real-ip
+          true-client-ip
+          x-client-ip
+          x-forwarded
+          forwarded-for
+          x-cluster-client-ip
+          fastly-client-ip
+          cf-connecting-ip
+          cf-connecting-ipv6
+        ].freeze
+
+        class << self
+          # Returns a client IP associated with the request if it was
+          #   retrieved successfully.
+          #
+          #
+          # @param [Datadog::Core::HeaderCollection, #get, nil] headers The request headers
+          # @param [Array<String>] list of headers to check.
+          # @return [String] IP value without the port and the zone indentifier.
+          # @return [nil] when no valid IP value found.
+          def stripped_ip_from_request_headers(headers, ip_headers_to_check: DEFAULT_IP_HEADERS_NAMES)
+            ip = ip_header(headers, ip_headers_to_check)
+
+            ip ? ip.to_s : nil
+          end
+
+          # @param [String] IP value.
+          # @return [String] IP value without the port and the zone indentifier.
+          # @return [nil] when no valid IP value found.
+          def stripped_ip(ip)
+            ip = ip_to_ipaddr(ip)
+            ip ? ip.to_s : nil
+          end
+
+          private
+
+          # @param [String] IP value.
+          # @return [IPaddr]
+          # @return [nil] when no valid IP value found.
+          def ip_to_ipaddr(ip)
+            return unless ip
+
+            clean_ip = if likely_ipv4?(ip)
+                         strip_ipv4_port(ip)
+                       else
+                         strip_zone_specifier(strip_ipv6_port(ip))
+                       end
+
+            begin
+              IPAddr.new(clean_ip)
+            rescue IPAddr::Error
+              nil
+            end
+          end
+
+          def ip_header(headers, ip_headers_to_check)
+            return unless headers
+
+            ip_headers_to_check.each do |name|
+              value = headers.get(name)
+
+              next unless value
+
+              ips = value.split(',')
+              ips.each do |ip|
+                parsed_ip = ip_to_ipaddr(ip.strip)
+
+                return parsed_ip if global_ip?(parsed_ip)
+              end
+            end
+
+            nil
+          end
+
+          # Returns whether the given value is more likely to be an IPv4 than an IPv6 address.
+          #
+          # This is done by checking if a dot (`'.'`) character appears before a colon (`':'`) in the value.
+          # The rationale is that in valid IPv6 addresses, colons will always preced dots,
+          #   and in valid IPv4 addresses dots will always preced colons.
+          def likely_ipv4?(value)
+            dot_index = value.index('.') || value.size
+            colon_index = value.index(':') || value.size
+
+            dot_index < colon_index
+          end
+
+          def strip_zone_specifier(ipv6)
+            ipv6.gsub(/%.*/, '')
+          end
+
+          def strip_ipv6_port(ip)
+            if /\[(.*)\](?::\d+)?/ =~ ip
+              Regexp.last_match(1)
+            else
+              ip
+            end
+          end
+
+          def strip_ipv4_port(ip)
+            ip.gsub(/:\d+\z/, '')
+          end
+
+          def global_ip?(parsed_ip)
+            parsed_ip && !private?(parsed_ip) && !loopback?(parsed_ip) && !link_local?(parsed_ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.private?
+          def private?(ip)
+            Datadog::Core::Vendor::IPAddr.private?(ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.link_local?
+          def link_local?(ip)
+            Datadog::Core::Vendor::IPAddr.link_local?(ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.loopback
+          def loopback?(ip)
+            Datadog::Core::Vendor::IPAddr.loopback?(ip)
+          end
+        end
+      end
+    end
+  end
+end