datadog 2.7.1 → 2.18.0

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

@@ -6,8 +6,10 @@ require_relative '../utils/sequence'
 module Datadog
   module Core
     module Telemetry
-      # Collection of telemetry events
-      class Event
+      # Collection of telemetry events.
+      #
+      # @api private
+      module Event
         extend Core::Utils::Forking
 
         # returns sequence that increments every time the configuration changes
@@ -15,388 +17,20 @@ module Datadog
           after_fork! { @sequence = Datadog::Core::Utils::Sequence.new(1) }
           @sequence ||= Datadog::Core::Utils::Sequence.new(1)
         end
-
-        # Base class for all Telemetry V2 events.
-        class Base
-          # The type of the event.
-          # It must be one of the stings defined in the Telemetry V2
-          # specification for event names.
-          def type
-            raise NotImplementedError, 'Must be implemented by subclass'
-          end
-
-          # The JSON payload for the event.
-          def payload
-            {}
-          end
-        end
-
-        # Telemetry class for the 'app-started' event
-        class AppStarted < Base
-          def type
-            'app-started'
-          end
-
-          def payload
-            {
-              products: products,
-              configuration: configuration,
-              install_signature: install_signature,
-              # DEV: Not implemented yet
-              # error: error, # Start-up errors
-            }
-          end
-
-          private
-
-          def products
-            # @type var products: Hash[Symbol, Hash[Symbol, Object]]
-            products = {
-              appsec: {
-                enabled: Datadog::AppSec.enabled?,
-              },
-              profiler: {
-                enabled: Datadog::Profiling.enabled?,
-              },
-              # DEV: Not implemented yet
-              # dynamic_instrumentation: {
-              #   enabled: true,
-              # }
-            }
-
-            if (unsupported_reason = Datadog::Profiling.unsupported_reason)
-              products[:profiler][:error] = {
-                code: 1, # Error code. 0 if no error.
-                message: unsupported_reason,
-              }
-            end
-
-            products
-          end
-
-          TARGET_OPTIONS = %w[
-            logger.level
-            profiling.advanced.code_provenance_enabled
-            profiling.advanced.endpoint.collection.enabled
-            profiling.enabled
-            runtime_metrics.enabled
-            tracing.analytics.enabled
-            tracing.propagation_style_extract
-            tracing.propagation_style_inject
-            tracing.enabled
-            tracing.log_injection
-            tracing.partial_flush.enabled
-            tracing.partial_flush.min_spans_threshold
-            tracing.report_hostname
-            tracing.sampling.rate_limit
-          ].freeze
-
-          # rubocop:disable Metrics/AbcSize
-          # rubocop:disable Metrics/MethodLength
-          def configuration
-            config = Datadog.configuration
-            seq_id = Event.configuration_sequence.next
-
-            list = [
-              conf_value('DD_AGENT_HOST', config.agent.host, seq_id),
-              conf_value('DD_AGENT_TRANSPORT', agent_transport(config), seq_id),
-              conf_value('DD_TRACE_SAMPLE_RATE', to_value(config.tracing.sampling.default_rate), seq_id),
-              conf_value(
-                'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED',
-                config.tracing.contrib.global_default_service_name.enabled,
-                seq_id
-              ),
-            ]
-
-            peer_service_mapping_str = ''
-            unless config.tracing.contrib.peer_service_mapping.empty?
-              peer_service_mapping = config.tracing.contrib.peer_service_mapping
-              peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
-            end
-            list << conf_value('DD_TRACE_PEER_SERVICE_MAPPING', peer_service_mapping_str, seq_id)
-
-            # Whitelist of configuration options to send in additional payload object
-            TARGET_OPTIONS.each do |option|
-              split_option = option.split('.')
-              list << conf_value(option, to_value(config.dig(*split_option)), seq_id)
-            end
-
-            # Add some more custom additional payload values here
-            list.push(
-              conf_value('tracing.auto_instrument.enabled', !defined?(Datadog::AutoInstrument::LOADED).nil?, seq_id),
-              conf_value(
-                'tracing.writer_options.buffer_size',
-                to_value(config.tracing.writer_options[:buffer_size]),
-                seq_id
-              ),
-              conf_value(
-                'tracing.writer_options.flush_interval',
-                to_value(config.tracing.writer_options[:flush_interval]),
-                seq_id
-              ),
-              conf_value(
-                'tracing.opentelemetry.enabled',
-                !defined?(Datadog::OpenTelemetry::LOADED).nil?,
-                seq_id
-              ),
-            )
-            list << conf_value('logger.instance', config.logger.instance.class.to_s, seq_id) if config.logger.instance
-            if config.respond_to?('appsec')
-              list << conf_value('appsec.enabled', config.dig('appsec', 'enabled'), seq_id)
-              list << conf_value('appsec.sca_enabled', config.dig('appsec', 'sca_enabled'), seq_id)
-            end
-            list << conf_value('ci.enabled', config.dig('ci', 'enabled'), seq_id) if config.respond_to?('ci')
-
-            list.reject! { |entry| entry[:value].nil? }
-            list
-          end
-          # rubocop:enable Metrics/AbcSize
-          # rubocop:enable Metrics/MethodLength
-
-          def agent_transport(config)
-            adapter = Core::Configuration::AgentSettingsResolver.call(config).adapter
-            if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
-              'UDS'
-            else
-              'TCP'
-            end
-          end
-
-          def conf_value(name, value, seq_id, origin = 'code')
-            {
-              name: name,
-              value: value,
-              origin: origin,
-              seq_id: seq_id,
-            }
-          end
-
-          def to_value(value)
-            # TODO: Add float if telemetry starts accepting it
-            case value
-            when Integer, String, true, false, nil
-              value
-            else
-              value.to_s
-            end
-          end
-
-          def install_signature
-            config = Datadog.configuration
-            {
-              install_id: config.dig('telemetry', 'install_id'),
-              install_type: config.dig('telemetry', 'install_type'),
-              install_time: config.dig('telemetry', 'install_time'),
-            }
-          end
-        end
-
-        # Telemetry class for the 'app-dependencies-loaded' event
-        class AppDependenciesLoaded < Base
-          def type
-            'app-dependencies-loaded'
-          end
-
-          def payload
-            { dependencies: dependencies }
-          end
-
-          private
-
-          def dependencies
-            Gem.loaded_specs.collect do |name, gem|
-              {
-                name: name,
-                version: gem.version.to_s,
-                # hash: nil,
-              }
-            end
-          end
-        end
-
-        # Telemetry class for the 'app-integrations-change' event
-        class AppIntegrationsChange < Base
-          def type
-            'app-integrations-change'
-          end
-
-          def payload
-            { integrations: integrations }
-          end
-
-          private
-
-          def integrations
-            instrumented_integrations = Datadog.configuration.tracing.instrumented_integrations
-            Datadog.registry.map do |integration|
-              is_instrumented = instrumented_integrations.include?(integration.name)
-
-              is_enabled = is_instrumented ? !!integration.klass.patcher.patch_successful : false
-
-              version = integration.klass.class.version ? integration.klass.class.version.to_s : nil
-
-              res = {
-                name: integration.name.to_s,
-                enabled: is_enabled,
-                version: version,
-                compatible: integration.klass.class.compatible?,
-                error: (patch_error(integration) if is_instrumented && !is_enabled),
-                # TODO: Track if integration is instrumented by manual configuration or by auto instrumentation
-                # auto_enabled: is_enabled && ???,
-              }
-              res.reject! { |_, v| v.nil? }
-              res
-            end
-          end
-
-          def patch_error(integration)
-            patch_error_result = integration.klass.patcher.patch_error_result
-            return patch_error_result.compact.to_s if patch_error_result
-
-            # If no error occurred during patching, but integration is still not instrumented
-            "Available?: #{integration.klass.class.available?}" \
-            ", Loaded? #{integration.klass.class.loaded?}" \
-            ", Compatible? #{integration.klass.class.compatible?}" \
-            ", Patchable? #{integration.klass.class.patchable?}"
-          end
-        end
-
-        # Telemetry class for the 'app-client-configuration-change' event
-        class AppClientConfigurationChange < Base
-          def type
-            'app-client-configuration-change'
-          end
-
-          def initialize(changes, origin)
-            super()
-            @changes = changes
-            @origin = origin
-          end
-
-          def payload
-            { configuration: configuration }
-          end
-
-          def configuration
-            config = Datadog.configuration
-            seq_id = Event.configuration_sequence.next
-
-            res = @changes.map do |name, value|
-              {
-                name: name,
-                value: value,
-                origin: @origin,
-                seq_id: seq_id,
-              }
-            end
-
-            unless config.dig('appsec', 'sca_enabled').nil?
-              res << {
-                name: 'appsec.sca_enabled',
-                value: config.appsec.sca_enabled,
-                origin: 'code',
-                seq_id: seq_id,
-              }
-            end
-
-            res
-          end
-        end
-
-        # Telemetry class for the 'app-heartbeat' event
-        class AppHeartbeat < Base
-          def type
-            'app-heartbeat'
-          end
-        end
-
-        # Telemetry class for the 'app-closing' event
-        class AppClosing < Base
-          def type
-            'app-closing'
-          end
-        end
-
-        # Telemetry class for the 'generate-metrics' event
-        class GenerateMetrics < Base
-          def type
-            'generate-metrics'
-          end
-
-          def initialize(namespace, metric_series)
-            super()
-            @namespace = namespace
-            @metric_series = metric_series
-          end
-
-          def payload
-            {
-              namespace: @namespace,
-              series: @metric_series.map(&:to_h)
-            }
-          end
-        end
-
-        # Telemetry class for the 'logs' event
-        class Log < Base
-          LEVELS = {
-            error: 'ERROR',
-            warn: 'WARN',
-          }.freeze
-
-          def type
-            'logs'
-          end
-
-          def initialize(message:, level:, stack_trace: nil)
-            super()
-            @message = message
-            @stack_trace = stack_trace
-            @level = LEVELS.fetch(level) { |k| raise ArgumentError, "Invalid log level :#{k}" }
-          end
-
-          def payload
-            {
-              logs: [
-                {
-                  message: @message,
-                  level: @level,
-                  stack_trace: @stack_trace,
-                }.compact
-              ]
-            }
-          end
-        end
-
-        # Telemetry class for the 'distributions' event
-        class Distributions < GenerateMetrics
-          def type
-            'distributions'
-          end
-        end
-
-        # Telemetry class for the 'message-batch' event
-        class MessageBatch
-          attr_reader :events
-
-          def type
-            'message-batch'
-          end
-
-          def initialize(events)
-            @events = events
-          end
-
-          def payload
-            @events.map do |event|
-              {
-                request_type: event.type,
-                payload: event.payload,
-              }
-            end
-          end
-        end
       end
     end
   end
 end
+
+require_relative 'event/base'
+require_relative 'event/app_client_configuration_change'
+require_relative 'event/app_closing'
+require_relative 'event/app_dependencies_loaded'
+require_relative 'event/app_heartbeat'
+require_relative 'event/app_integrations_change'
+require_relative 'event/app_started'
+require_relative 'event/synth_app_client_configuration_change'
+require_relative 'event/generate_metrics'
+require_relative 'event/distributions'
+require_relative 'event/log'
+require_relative 'event/message_batch'

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

@@ -13,6 +13,7 @@ module Datadog
         ENV_INSTALL_TYPE = 'DD_INSTRUMENTATION_INSTALL_TYPE'
         ENV_INSTALL_TIME = 'DD_INSTRUMENTATION_INSTALL_TIME'
         ENV_AGENTLESS_URL_OVERRIDE = 'DD_TELEMETRY_AGENTLESS_URL'
+        ENV_LOG_COLLECTION = 'DD_TELEMETRY_LOG_COLLECTION_ENABLED'
       end
     end
   end

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

@@ -1,108 +1,23 @@
 # frozen_string_literal: true
 
-require_relative '../response'
+# datadog-ci-rb versions 1.15.0 and lower require this file and guard
+# the require with a rescue of StandardError. Unfortunately LoadError,
+# which would be raised if the file is missing, is not a subclass of
+# StandardError and thus would not be caught by the rescue.
+# We provide this file with a dummy class in it to avoid exceptions
+# in datadog-ci-rb until version 2.0 is released.
+#
+# Note that datadog-ci-rb patches telemetry transport to be "real" even when
+# webmock is used; this patching won't work with datadog-ci-rb versions
+# 1.15.0 and older and dd-trace-rb 2.16.0 and newer. There will be no
+# errors/exceptions reported but telemetry events will not be sent.
 
 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 = 2
-
-            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)
-              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
-
-            # 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
+          class Net # rubocop:disable Lint/EmptyClass
           end
         end
       end

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

@@ -14,8 +14,8 @@ module Datadog
       #   read: lib/datadog/core/telemetry/logging.rb
       module Logger
         class << self
-          def report(exception, level: :error, description: nil)
-            instance&.report(exception, level: level, description: description)
+          def report(exception, level: :error, description: nil, pii_safe: false)
+            instance&.report(exception, level: level, description: description, pii_safe: pii_safe)
           end
 
           def error(description)
@@ -34,9 +34,10 @@ module Datadog
             #
             # The downside is: this leaves us unable to report telemetry during component initialization.
             components = Datadog.send(:components, allow_initialization: false)
+            telemetry = components&.telemetry
 
-            if components && components.telemetry
-              components.telemetry
+            if telemetry
+              telemetry
             else
               Datadog.logger.warn(
                 'Failed to send telemetry before components initialization or within components lifecycle'

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

@@ -41,15 +41,21 @@ module Datadog
               else
                 'REDACTED'
               end
-            end.join(',')
+            end.join("\n")
           end
         end
 
-        def report(exception, level: :error, description: nil)
-          # Annoymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
-          message = +''
-          message << (exception.class.name || exception.class.inspect)
-          message << ':' << description if description
+        def report(exception, level: :error, description: nil, pii_safe: false)
+          # Anonymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
+          message = +"#{exception.class.name || exception.class.inspect}" # standard:disable Style/RedundantInterpolation
+
+          exception_message = pii_safe ? exception.message : nil
+
+          if description || exception_message
+            message << ':'
+            message << " #{description}" if description
+            message << " (#{exception.message})" if exception_message
+          end
 
           event = Event::Log.new(
             message: message,

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

@@ -20,7 +20,7 @@ module Datadog
           end
 
           def id
-            @id ||= "#{type}::#{name}::#{tags.join(',')}"
+            @id ||= "#{type}::#{name}::#{tags.join(",")}"
           end
 
           def track(value)
@@ -41,6 +41,18 @@ module Datadog
             }
           end
 
+          def ==(other)
+            other.is_a?(self.class) &&
+              name == other.name &&
+              values == other.values && tags == other.tags && common == other.common && type == other.type
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [self.class, name, values, tags, common, type].hash
+          end
+
           private
 
           def tags_to_array(tags)
@@ -71,6 +83,16 @@ module Datadog
             res[:interval] = interval
             res
           end
+
+          def ==(other)
+            super && interval == other.interval
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [super, interval].hash
+          end
         end
 
         # Count metric adds up all the submitted values in a time interval. This would be suitable for a
@@ -86,9 +108,9 @@ module Datadog
             value = value.to_i
 
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] += value
             end
             nil
@@ -107,9 +129,9 @@ module Datadog
 
           def track(value)
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] = value
             end
             nil
@@ -133,7 +155,7 @@ module Datadog
 
           def track(value = 1.0)
             @value += value
-            @values = [[Time.now.to_i, @value / interval]]
+            @values = [[Core::Utils::Time.now.to_i, @value / interval]]
             nil
           end
         end

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

@@ -11,17 +11,17 @@ module Datadog
         class << self
           using Core::Utils::Hash::Refinement
 
-          def build_payload(event, seq_id)
+          def build_payload(event, seq_id, api_version: 'v2', debug: false)
             hash = {
-              api_version: Http::Ext::API_VERSION,
+              api_version: api_version,
               application: application,
-              debug: false,
+              debug: debug,
               host: host,
               payload: event.payload,
               request_type: event.type,
               runtime_id: Core::Environment::Identity.id,
               seq_id: seq_id,
-              tracer_time: Time.now.to_i,
+              tracer_time: Core::Utils::Time.now.to_i,
             }
             hash.compact!
             hash