datadog 2.28.0 → 2.41.0

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'datadog/tracing/utils'
+require "datadog/tracing/utils"
 
 module Datadog
   module OpenTelemetry
@@ -30,9 +30,9 @@ module Datadog
           if (span = datadog_span)
             # Sets the exception attributes as span error tags. The values in the attribute hash MUST
             # take precedence over the type, message and stacktrace inferred from the exception object
-            type = attributes&.[]('exception.type') || exception.class.to_s
-            message = attributes&.[]('exception.message') || exception.message
-            stacktrace = attributes&.[]('exception.stacktrace') || exception.full_message(highlight: false, order: :top)
+            type = attributes&.[]("exception.type") || exception.class.to_s
+            message = attributes&.[]("exception.message") || exception.message
+            stacktrace = attributes&.[]("exception.stacktrace") || exception.full_message(highlight: false, order: :top)
             span.set_error_tags([type, message, stacktrace])
           end
           res
@@ -67,22 +67,22 @@ module Datadog
 
         # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def self.enrich_name(kind, attrs)
-          if attrs.key?('http.request.method')
-            return 'http.server.request' if kind == :server
-            return 'http.client.request' if kind == :client
+          if attrs.key?("http.request.method")
+            return "http.server.request" if kind == :server
+            return "http.client.request" if kind == :client
           end
 
-          return "#{attrs["db.system"]}.query" if attrs.key?('db.system') && kind == :client
+          return "#{attrs["db.system"]}.query" if attrs.key?("db.system") && kind == :client
 
-          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+          if (attrs.key?("messaging.system") || attrs.key?("messaging.operation")) &&
               [:consumer, :producer, :server, :client].include?(kind)
 
             return "#{attrs["messaging.system"]}.#{attrs["messaging.operation"]}"
           end
 
-          if attrs.key?('rpc.system')
-            if attrs['rpc.system'] == 'aws-api' && kind == :client
-              service = attrs['rpc.service']
+          if attrs.key?("rpc.system")
+            if attrs["rpc.system"] == "aws-api" && kind == :client
+              service = attrs["rpc.service"]
               return "aws.#{service || "client"}.request"
             end
 
@@ -93,24 +93,24 @@ module Datadog
             end
           end
 
-          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
-            provider = attrs['faas.invoked_provider']
-            name = attrs['faas.invoked_name']
+          if attrs.key?("faas.invoked_provider") && attrs.key?("faas.invoked_name") && kind == :client
+            provider = attrs["faas.invoked_provider"]
+            name = attrs["faas.invoked_name"]
             return "#{provider}.#{name}.invoke"
           end
 
-          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?('faas.trigger') && kind == :server
+          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?("faas.trigger") && kind == :server
 
-          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+          return "graphql.server.request" if attrs.key?("graphql.operation.type")
 
           if kind == :server
-            protocol = attrs['network.protocol.name']
-            return protocol ? "#{protocol}.server.request" : 'server.request'
+            protocol = attrs["network.protocol.name"]
+            return protocol ? "#{protocol}.server.request" : "server.request"
           end
 
           if kind == :client
-            protocol = attrs['network.protocol.name']
-            return protocol ? "#{protocol}.client.request" : 'client.request'
+            protocol = attrs["network.protocol.name"]
+            return protocol ? "#{protocol}.client.request" : "client.request"
           end
 
           kind.to_s
@@ -129,7 +129,7 @@ module Datadog
           # DEV: clones the hash, causing unnecessary overhead.
           if @attributes.key?(key)
             # Try to find a richer operation name, unless an explicit override was provided.
-            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+            if !@attributes.key?("operation.name") && (rich_name = Span.enrich_name(kind, @attributes))
               span.name = rich_name.downcase
             end
 
@@ -143,7 +143,7 @@ module Datadog
           else
             span.clear_tag(key)
 
-            if key == 'service.name'
+            if key == "service.name"
               # By removing the service name, we set it to the fallback default,
               # effectively removing the `service` attribute from OpenTelemetry's perspective.
               span.service = Datadog.send(:components).tracer.default_service
@@ -156,24 +156,24 @@ module Datadog
         # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
         # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def override_datadog_values(span, key, value)
-          span.name = value if key == 'operation.name'
-          span.resource = value if key == 'resource.name'
-          span.service = value if key == 'service.name'
-          span.type = value if key == 'span.type'
+          span.name = value if key == "operation.name"
+          span.resource = value if key == "resource.name"
+          span.service = value if key == "service.name"
+          span.type = value if key == "span.type"
 
-          if key == 'analytics.event' && value.respond_to?(:casecmp)
+          if key == "analytics.event" && value.respond_to?(:casecmp)
             Datadog::Tracing::Analytics.set_sample_rate(
               span,
-              (value.casecmp('true') == 0) ? 1 : 0
+              (value.casecmp("true") == 0) ? 1 : 0
             )
           end
 
-          span.set_tag('http.status_code', value) if key == 'http.response.status_code'
+          span.set_tag("http.status_code", value) if key == "http.response.status_code"
         end
         # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
-        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
-          'span.type', 'http.response.status_code'].freeze
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ["analytics.event", "operation.name", "resource.name", "service.name",
+          "span.type", "http.response.status_code"].freeze
 
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end

data/lib/datadog/opentelemetry/sdk.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../tracing/ext"
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      TELEMETRY_TAGS = {"protocol" => "http", "encoding" => "protobuf"}.freeze
+
+      def self.telemetry_inc(metric_name, value)
+        telemetry&.inc(Datadog::Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: TELEMETRY_TAGS)
+      end
+
+      def self.telemetry
+        Datadog.send(:components).telemetry
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../core/configuration/ext"
+require_relative "../core/environment/socket"
+
+module Datadog
+  module OpenTelemetry
+    # Shared resource building and signal-specific config fallback logic for Logs and Metrics.
+    module SignalConfiguration
+      private
+
+      def create_resource
+        resource_attributes = {}
+
+        @settings.tags&.each do |key, value| # steep:ignore
+          otel_key = case key
+          when "service" then "service.name"
+          when "env" then "deployment.environment"
+          when "version" then "service.version"
+          else key
+          end
+          resource_attributes[otel_key] = value
+        end
+
+        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
+        resource_attributes["deployment.environment"] = @settings.env if @settings.env # steep:ignore
+        resource_attributes["service.version"] = @settings.version if @settings.version # steep:ignore
+
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        if hostname
+          if hostname == @settings.hostname # steep:ignore
+            resource_attributes["host.name"] = hostname
+          elsif !resource_attributes.key?("host.name")
+            resource_attributes["host.name"] = hostname
+          end
+        end
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      # Returns the signal-specific option value when explicitly set,
+      # otherwise falls back to the general OTLP exporter config or computed_default.
+      def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
+        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        if signal_settings.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+        else
+          signal_settings.public_send(option_name)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../tracing/trace_digest'
+require_relative "../tracing/trace_digest"
 
 module Datadog
   module OpenTelemetry

data/lib/datadog/opentelemetry.rb

@@ -9,20 +9,21 @@
 # components supported by Datadog.
 
 # Load Tracing
-require_relative 'tracing'
-require_relative 'tracing/contrib'
+require_relative "tracing"
+require_relative "tracing/contrib"
 
-require_relative 'opentelemetry/api/context'
-require_relative 'opentelemetry/api/baggage'
+require_relative "opentelemetry/api/context"
+require_relative "opentelemetry/api/baggage"
 
 # DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
 # DEV: and checks for compatibility?
 # DEV: This is different from our existing OpenTracer API, but there are many safety
 # DEV: features built into Contrib instrumentation today.
-require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
-require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
+require_relative "opentelemetry/sdk/configurator" if defined?(OpenTelemetry::SDK)
+require_relative "opentelemetry/sdk/trace/span" if defined?(OpenTelemetry::SDK)
 
-require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+require_relative "opentelemetry/metrics" if defined?(OpenTelemetry::SDK::Metrics)
+require_relative "opentelemetry/logs" if defined?(OpenTelemetry::SDK::Logs)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -14,6 +14,9 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
+        # @rbs standard_library_path: ::String
+        # @rbs ruby_native_filename: ::String?
+        # @rbs return: void
         def initialize(
           standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
           ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
@@ -35,6 +38,9 @@ module Datadog
           )
         end
 
+        # @rbs loaded_files: ::Array[::String]
+        # @rbs loaded_specs: ::Array[::Gem::BasicSpecification]
+        # @rbs return: self
         def refresh(loaded_files: $LOADED_FEATURES, loaded_specs: Gem.loaded_specs.values)
           record_loaded_specs(loaded_specs)
           record_loaded_files(loaded_files)
@@ -42,19 +48,20 @@ module Datadog
           self
         end
 
+        #: () -> ::String
         def generate_json
           JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
 
-        attr_reader \
-          :libraries_by_name,
-          :libraries_by_path,
-          :seen_files,
-          :seen_libraries,
-          :executable_paths
+        attr_reader :libraries_by_name #: ::Hash[::String, Library]
+        attr_reader :libraries_by_path #: ::Hash[::String, Library]
+        attr_reader :seen_files #: ::Set[::String]
+        attr_reader :seen_libraries #: ::Set[Library]
+        attr_reader :executable_paths #: ::Array[::String]
 
+        #: (Library) -> void
         def record_library(library)
           libraries_by_name[library.name] = library
           libraries_by_path[library.path] = library
@@ -71,10 +78,12 @@ module Datadog
         #
         # Alternatively/in the future we could instead use a trie to match paths, but I doubt for the data sizes we're
         # looking at that a trie is that much faster than using Ruby's built-in native collections.
+        #: () -> void
         def sort_libraries_by_longest_path_first
           @libraries_by_path = @libraries_by_path.sort.reverse!.to_h
         end
 
+        #: (::Array[::Gem::BasicSpecification]) -> void
         def record_loaded_specs(loaded_specs)
           recorded_library = false
 
@@ -103,6 +112,7 @@ module Datadog
           sort_libraries_by_longest_path_first if recorded_library
         end
 
+        #: (::Array[::String]) -> void
         def record_loaded_files(loaded_files)
           loaded_files.each do |file_path|
             next if seen_files.include?(file_path)
@@ -125,6 +135,7 @@ module Datadog
         # bundler complaints here impacting the application. (Bundler tends to go "something is wrong, raise!" which
         # I think makes a lot of sense given how bundler is intended to be used, but for this our kind of "ask a few
         # questions usage" it's not what we want.)
+        #: () -> ::String?
         def bundler_bin_path
           return unless defined?(Bundler)
 
@@ -135,7 +146,7 @@ module Datadog
         rescue Exception => e # rubocop:disable Lint/RescueException
           Datadog.logger.debug(
             "CodeProvenance#bundler_bin_path failed. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           nil
         end
@@ -149,8 +160,21 @@ module Datadog
         # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
         # fields. (Also, we have a spec for this)
         class Library
-          attr_reader :kind, :name, :version
-
+          # @rbs @kind: ::String
+          # @rbs @name: ::String
+          # @rbs @version: ::String
+          # @rbs @paths: ::Array[::String]
+
+          attr_reader :kind #: ::String
+          attr_reader :name #: ::String
+          attr_reader :version #: ::String
+
+          # @rbs kind: ::String
+          # @rbs name: ::String
+          # @rbs version: ::String | ::Gem::Version
+          # @rbs path: ::String
+          # @rbs extra_paths: ::Array[::String?]
+          # @rbs return: void
           def initialize(kind:, name:, version:, path:, extra_paths:)
             extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
             @kind = kind.freeze
@@ -160,11 +184,12 @@ module Datadog
             freeze
           end
 
+          #: (?::JSON::State?) -> ::String
           def to_json(arg = nil)
-            # Steep: https://github.com/ruby/rbs/pull/2691 (remove after RBS 4.0 release)
-            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg) # steep:ignore ArgumentTypeMismatch
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
+          #: () -> ::String
           def path
             @paths.first
           end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -9,12 +9,32 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_cpu_and_wall_time_worker.c`
       class CpuAndWallTimeWorker
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @failure_exception: ::Exception?
+        # @rbs @idle_sampling_helper: IdleSamplingHelper
+        # @rbs @wait_until_running_mutex: ::Thread::Mutex
+        # @rbs @wait_until_running_condition: ::Thread::ConditionVariable
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
+        # @rbs gc_profiling_enabled: bool
+        # @rbs no_signals_workaround_enabled: bool
+        # @rbs thread_context_collector: Datadog::Profiling::Collectors::ThreadContext
+        # @rbs dynamic_sampling_rate_overhead_target_percentage: Float
+        # @rbs cpu_sampling_interval_ms: ::Integer
+        # @rbs idle_sampling_helper: Datadog::Profiling::Collectors::IdleSamplingHelper
+        # @rbs dynamic_sampling_rate_enabled: bool
+        # @rbs allocation_profiling_enabled: bool
+        # @rbs allocation_counting_enabled: bool
+        # @rbs gvl_profiling_enabled: bool
+        # @rbs sighandler_sampling_enabled: bool
+        # @rbs skip_idle_samples_for_testing: false
+        # @rbs return: void
         def initialize(
           gc_profiling_enabled:,
           no_signals_workaround_enabled:,
@@ -24,11 +44,12 @@ module Datadog
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
           sighandler_sampling_enabled:,
+          cpu_sampling_interval_ms:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new
+          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -39,6 +60,10 @@ module Datadog
             )
           end
 
+          if cpu_sampling_interval_ms < 1
+            raise ArgumentError, "cpu_sampling_interval_ms must be a positive integer, got #{cpu_sampling_interval_ms}"
+          end
+
           self.class._native_initialize(
             self_instance: self,
             thread_context_collector: thread_context_collector,
@@ -52,6 +77,7 @@ module Datadog
             gvl_profiling_enabled: gvl_profiling_enabled,
             sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
+            cpu_sampling_interval_ms: cpu_sampling_interval_ms,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -61,6 +87,8 @@ module Datadog
           @wait_until_running_condition = ConditionVariable.new
         end
 
+        # @rbs on_failure_proc: (^(?log_failure: bool) -> void)?
+        # @rbs return: bool?
         def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -75,12 +103,19 @@ module Datadog
               self.class._native_sampling_loop(self)
 
               Datadog.logger.debug("CpuAndWallTimeWorker thread stopping cleanly")
+            rescue Profiling::ExistingSignalHandler => e
+              @failure_exception = e
+              Datadog.logger.warn(
+                "Profiling was not started as another profiler or gem is already using the SIGPROF signal. " \
+                "Please disable the other profiler to use Datadog profiling."
+              )
+              on_failure_proc&.call(log_failure: false)
             rescue Exception => e # rubocop:disable Lint/RescueException
               @failure_exception = e
               operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Operation: #{operation_name} Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Operation: #{operation_name} Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
               Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error: #{operation_name}")
@@ -92,6 +127,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
@@ -108,14 +144,17 @@ module Datadog
           end
         end
 
+        #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats
           self.class._native_stats(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats_and_reset_not_thread_safe
           stats = self.stats
           self.class._native_stats_reset_not_thread_safe(self)
@@ -123,22 +162,30 @@ module Datadog
         end
 
         # Useful for testing, to e.g. make sure the profiler is running before we start running some code we want to observe
+        # @rbs timeout_seconds: ::Integer?
+        # @rbs return: true
         def wait_until_running(timeout_seconds: 5)
           @wait_until_running_mutex.synchronize do
             return true if self.class._native_is_running?(self)
 
             @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
 
+            # Not using `_native_is_running?(self) || raise(...)` here: `_native_is_running?` is declared
+            # to return `bool`, so steep infers the `||` expression as `bool` too and rejects it against
+            # this method's declared `true` return type. The explicit `if`/`else` type-checks correctly.
+            # rubocop:disable Style/RedundantCondition
             if self.class._native_is_running?(self)
               true
             else
               raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
             end
+            # rubocop:enable Style/RedundantCondition
           end
         end
 
         private
 
+        #: () -> void
         def signal_running
           @wait_until_running_mutex.synchronize { @wait_until_running_condition.broadcast }
         end

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -8,17 +8,24 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_idle_sampling_helper.c`
       class IdleSamplingHelper
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
-        def initialize
+        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
+        def initialize(thread_context_collector:)
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
+          @thread_context_collector = thread_context_collector
         end
 
+        #: () -> (nil | true)
         def start
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -32,14 +39,14 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self)
+              self.class._native_idle_sampling_loop(self, @thread_context_collector)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end
@@ -50,6 +57,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")

data/lib/datadog/profiling/collectors/info.rb

@@ -14,11 +14,18 @@ module Datadog
       # could be seen as overkill for this case but it allows us to centralize information
       # gathering and easily support more flexible/dynamic info collection in the future.
       class Info
+        # @rbs @info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @platform_info: ::Hash[::Symbol, untyped]
+        # @rbs @runtime_info: ::Hash[::Symbol, untyped]
+        # @rbs @application_info: ::Hash[::Symbol, untyped]
+        # @rbs @profiler_info: ::Hash[::Symbol, untyped]?
+        # @rbs @gc_tuning_info: ::Hash[::Symbol, ::String]
+
+        #: (untyped) -> void
         def initialize(settings)
           @profiler_info = nil
 
-          # Steep: https://github.com/soutaro/steep/issues/363
-          @info = { # steep:ignore IncompatibleAssignment
+          @info = {
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),
@@ -26,7 +33,7 @@ module Datadog
           }.freeze
         end
 
-        attr_reader :info
+        attr_reader :info #: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
 
         private
 
@@ -69,16 +76,18 @@ module Datadog
         # gets initialized before a user has a chance to configure the library.
         START_TIME = Time.now.utc.freeze
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info
           @platform_info ||= {
             container_id: Datadog::Core::Environment::Container.container_id,
             hostname: Datadog::Core::Environment::Platform.hostname,
             kernel_name: Datadog::Core::Environment::Platform.kernel_name,
             kernel_release: Datadog::Core::Environment::Platform.kernel_release,
-            kernel_version: Datadog::Core::Environment::Platform.kernel_version
+            kernel_version: Datadog::Core::Environment::Platform.kernel_version,
           }.freeze
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_runtime_info
           @runtime_info ||= {
             engine: Datadog::Core::Environment::Identity.lang_engine,
@@ -88,6 +97,7 @@ module Datadog
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_application_info(settings)
           @application_info ||= {
             start_time: START_TIME.iso8601,
@@ -97,6 +107,7 @@ module Datadog
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_profiler_info(settings)
           @profiler_info ||= begin
             lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
@@ -123,6 +134,7 @@ module Datadog
         # instances without proper serialization.
         # This method navigates a settings object recursively, converting
         # it into more basic types that are trivially convertible to JSON.
+        #: (untyped) -> untyped
         def collect_settings_recursively(v)
           v = v.options_hash if v.respond_to?(:options_hash)
 
@@ -143,6 +155,7 @@ module Datadog
           end
         end
 
+        #: () -> ::Hash[::Symbol, ::String]
         def collect_gc_tuning_info
           return @gc_tuning_info if defined?(@gc_tuning_info)