datadog 2.17.0 → 2.19.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -39,60 +39,70 @@ module Datadog
       end
 
       # Duration is in seconds.
+      # path is the actual path of the instrumented file.
       def build_executed(probe,
-        trace_point: nil, rv: nil, duration: nil, caller_locations: nil,
-        args: nil, kwargs: nil, serialized_entry_args: nil)
-        snapshot = if probe.line? && probe.capture_snapshot?
-          if trace_point.nil?
-            raise "Cannot create snapshot because there is no trace point"
-          end
-          get_local_variables(trace_point)
-        end
-        # TODO check how many stack frames we should be keeping/sending,
-        # this should be all frames for enriched probes and no frames for
-        # non-enriched probes?
-        build_snapshot(probe, rv: rv, snapshot: snapshot,
+        path: nil, rv: nil, duration: nil, caller_locations: nil,
+        serialized_locals: nil, args: nil, kwargs: nil, target_self: nil,
+        serialized_entry_args: nil)
+        build_snapshot(probe, rv: rv, serialized_locals: serialized_locals,
           # Actual path of the instrumented file.
-          path: trace_point&.path,
-          duration: duration, caller_locations: caller_locations, args: args, kwargs: kwargs,
+          path: path,
+          duration: duration,
+          # TODO check how many stack frames we should be keeping/sending,
+          # this should be all frames for enriched probes and no frames for
+          # non-enriched probes?
+          caller_locations: caller_locations,
+          args: args, kwargs: kwargs,
+          target_self: target_self,
           serialized_entry_args: serialized_entry_args)
       end
 
-      def build_snapshot(probe, rv: nil, snapshot: nil, path: nil,
-        duration: nil, caller_locations: nil, args: nil, kwargs: nil,
+      def build_snapshot(probe, rv: nil, serialized_locals: nil, path: nil,
+        # In Ruby everything is a method, therefore we should always have
+        # a target self. However, if we are not capturing a snapshot,
+        # there is no need to pass in the target self.
+        target_self: nil,
+        duration: nil, caller_locations: nil,
+        args: nil, kwargs: nil,
         serialized_entry_args: nil)
+        if probe.capture_snapshot? && !target_self
+          raise ArgumentError, "Asked to build snapshot with snapshot capture but target_self is nil"
+        end
+
         # TODO also verify that non-capturing probe does not pass
         # snapshot or vars/args into this method
         captures = if probe.capture_snapshot?
           if probe.method?
+            return_arguments = {
+              "@return": serializer.serialize_value(rv,
+                depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count),
+              self: serializer.serialize_value(target_self),
+            }
             {
               entry: {
                 # standard:disable all
                 arguments: if serialized_entry_args
                   serialized_entry_args
                 else
-                  (args || kwargs) && serializer.serialize_args(args, kwargs,
+                  (args || kwargs) && serializer.serialize_args(args, kwargs, target_self,
                     depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
                     attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count)
                 end,
-                throwable: nil,
                 # standard:enable all
               },
               return: {
-                arguments: {
-                  "@return": serializer.serialize_value(rv,
-                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count),
-                },
+                arguments: return_arguments,
                 throwable: nil,
               },
             }
           elsif probe.line?
             {
-              lines: snapshot && {
-                probe.line_no => {locals: serializer.serialize_vars(snapshot,
-                  depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                  attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)},
+              lines: serialized_locals && {
+                probe.line_no => {
+                  locals: serialized_locals,
+                  arguments: {self: serializer.serialize_value(target_self)},
+                },
               },
             }
           end
@@ -194,21 +204,6 @@ module Datadog
         (Core::Utils::Time.now.to_f * 1000).to_i
       end
 
-      def get_local_variables(trace_point)
-        # binding appears to be constructed on access, therefore
-        # 1) we should attempt to cache it and
-        # 2) we should not call +binding+ until we actually need variable values.
-        binding = trace_point.binding
-
-        # steep hack - should never happen
-        return {} unless binding
-
-        binding.local_variables.each_with_object({}) do |name, map|
-          value = binding.local_variable_get(name)
-          map[name] = value
-        end
-      end
-
       def active_trace
         if defined?(Datadog::Tracing)
           Datadog::Tracing.active_trace

data/lib/datadog/di/probe_notifier_worker.rb

@@ -183,7 +183,15 @@ module Datadog
       end
 
       def do_send_snapshot(batch)
-        snapshot_transport.send_input(batch)
+        snapshot_transport.send_input(batch, tags)
+      end
+
+      def tags
+        # DEV: The tags could be cached but they need to be recreated
+        # when process forks (since the child receives new runtime IDs).
+        Core::TagBuilder.tags(settings).merge(
+          'debugger_version' => Core::Environment::Identity.gem_datadog_version,
+        )
       end
 
       [

data/lib/datadog/di/serializer.rb

@@ -36,6 +36,10 @@ module Datadog
     # efficient but there would be additional overhead from passing this
     # parameter all the time and the API would get more complex.
     #
+    # Note: "self" cannot be used as a parameter name in Ruby, therefore
+    # there should never be a conflict between instance variable
+    # serialization and method parameters.
+    #
     # @api private
     class Serializer
       # Third-party library integration / custom serializers.
@@ -82,7 +86,11 @@ module Datadog
       # between positional and keyword arguments. We convert positional
       # arguments to keyword arguments ("arg1", "arg2", ...) and ensure
       # the positional arguments are listed first.
-      def serialize_args(args, kwargs,
+      #
+      # Instance variables are technically a hash just like kwargs,
+      # we take them as a separate parameter to avoid a hash merge
+      # in upstream code.
+      def serialize_args(args, kwargs, target_self,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
         counter = 0
@@ -91,7 +99,7 @@ module Datadog
           # Conversion to symbol is needed here to put args ahead of
           # kwargs when they are merged below.
           c[:"arg#{counter}"] = value
-        end.update(kwargs)
+        end.update(kwargs).update(self: target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count)
       end
 

data/lib/datadog/di/transport/http/input.rb

@@ -53,6 +53,16 @@ module Datadog
                 # Encode body & type
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
                 env.body = env.request.parcel.data
+                env.query = {
+                  # DEV: In theory we could serialize the tags here
+                  # rather than requiring them to be pre-serialized.
+                  # In practice the tags should be relatively static
+                  # (they would change when process forks, and hostname
+                  # could change at any time but probably we should ignore
+                  # those changes), therefore serializing the tags
+                  # every time would be wasteful.
+                  ddtags: env.request.serialized_tags,
+                }
 
                 super
               end

data/lib/datadog/di/transport/input.rb

@@ -12,6 +12,13 @@ module Datadog
         end
 
         class Request < Datadog::Core::Transport::Request
+          attr_reader :serialized_tags
+
+          def initialize(parcel, serialized_tags)
+            super(parcel)
+
+            @serialized_tags = serialized_tags
+          end
         end
 
         class Transport
@@ -28,10 +35,11 @@ module Datadog
             @apis[HTTP::API::INPUT]
           end
 
-          def send_input(payload)
+          def send_input(payload, tags)
             json = JSON.dump(payload)
             parcel = EncodedParcel.new(json)
-            request = Request.new(parcel)
+            serialized_tags = Core::TagBuilder.serialize_tags(tags)
+            request = Request.new(parcel, serialized_tags)
 
             response = @client.send_input_payload(request)
             unless response.ok?

data/lib/datadog/di.rb

@@ -35,9 +35,3 @@ module Datadog
     end
   end
 end
-
-# Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
-# trace point. Activate DI automatically on supported Ruby versions but
-# always load its settings so that, for example, turning DI off when
-# we are on Ruby 2.5 does not produce exceptions.
-require_relative 'di/boot' if RUBY_VERSION >= '2.6' && RUBY_ENGINE != 'jruby'

data/lib/datadog/kit/appsec/events/v2.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative '../../identity'
+
+module Datadog
+  module Kit
+    module AppSec
+      module Events
+        # The second version of Business Logic Events SDK
+        module V2
+          LOGIN_SUCCESS_EVENT = 'users.login.success'
+          LOGIN_FAILURE_EVENT = 'users.login.failure'
+          TELEMETRY_METRICS_NAMESPACE = 'appsec'
+          TELEMETRY_METRICS_SDK_EVENT = 'sdk.event'
+          TELEMETRY_METRICS_SDK_VERSION = 'v2'
+          TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
+            LOGIN_SUCCESS_EVENT => 'login_success',
+            LOGIN_FAILURE_EVENT => 'login_failure'
+          }.freeze
+
+          class << self
+            # Attach user login success information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_or_id [String, Hash<Symbol, String>] (optional) If a
+            #   String, considered as a user ID, if a Hash, considered as a user
+            #   attributes. The Hash must include `:id` as a key.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success('alice@example.com')
+            #
+            # @example Login and user attributes
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success(
+            #     'alice@example.com',
+            #     { id: 'user-123', email: 'alice@example.com', name: 'Alice' },
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_success(login, user_or_id = nil, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              user_attributes = build_user_attributes(user_or_id, login)
+
+              set_span_tags(span, metadata, namespace: LOGIN_SUCCESS_EVENT)
+              set_span_tags(span, user_attributes, namespace: "#{LOGIN_SUCCESS_EVENT}.usr")
+              span.set_tag('appsec.events.users.login.success.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.success.sdk', 'true')
+
+              trace.keep!
+
+              record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
+
+              # NOTE: Guard-clause will not work with Steep typechecking
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore
+
+              # NOTE: This is a fallback for the case when we don't have an ID,
+              #       but need to trigger WAF.
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            # Attach user login failure information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_exists [Boolean] Whether the user exists in the system.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure('alice@example.com')
+            #
+            # @example With user existence and metadata
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure(
+            #     'alice@example.com',
+            #     true,
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_failure(login, user_exists = false, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              unless user_exists.is_a?(TrueClass) || user_exists.is_a?(FalseClass)
+                raise TypeError, '`user_exists` argument must be a boolean'
+              end
+
+              set_span_tags(span, metadata, namespace: LOGIN_FAILURE_EVENT)
+              span.set_tag('appsec.events.users.login.failure.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.failure.sdk', 'true')
+              span.set_tag('appsec.events.users.login.failure.usr.login', login)
+              span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists.to_s)
+
+              trace.keep!
+
+              record_event_telemetry_metric(LOGIN_FAILURE_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_FAILURE_EVENT)
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            private
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_trace
+              return Datadog::Tracing.active_trace unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.trace
+            end
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_span
+              return Datadog::Tracing.active_span unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.span
+            end
+
+            def build_user_attributes(user_or_id, login)
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+
+              case user_or_id
+              when nil
+                { login: login }
+              when String
+                { login: login, id: user_or_id }
+              when Hash
+                raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
+                raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
+
+                user_or_id.merge(login: login)
+              else
+                raise TypeError, '`user_or_id` argument must be either String or Hash'
+              end
+            end
+
+            def set_span_tags(span, tags, namespace:)
+              tags.each do |name, value|
+                next if value.nil?
+
+                span.set_tag("appsec.events.#{namespace}.#{name}", value)
+              end
+            end
+
+            # TODO: In case if we need to introduce telemetry metrics to the SDK v1
+            #       or highly increase the number of metrics, this method should be
+            #       extracted into a proper module.
+            def record_event_telemetry_metric(event)
+              telemetry = ::Datadog.send(:components, allow_initialization: false)&.telemetry
+
+              if telemetry.nil?
+                return Datadog.logger.debug(
+                  'Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics'
+                )
+              end
+
+              tags = {
+                event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+              }
+              telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,10 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
-        def initialize(standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"))
+        def initialize(
+          standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
+          ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
+        )
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
@@ -26,6 +29,7 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
+              extra_path: ruby_native_filename,
             )
           )
         end
@@ -37,10 +41,6 @@ module Datadog
           self
         end
 
-        def generate
-          seen_libraries
-        end
-
         def generate_json
           JSON.generate(v1: seen_libraries.to_a)
         end
@@ -79,7 +79,15 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
-            record_library(Library.new(kind: "library", name: spec.name, version: spec.version, path: spec.gem_dir))
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_path: (spec.extension_dir if spec.extensions.any?),
+              )
+            )
             recorded_library = true
           end
 
@@ -110,11 +118,12 @@ module Datadog
         class Library
           attr_reader :kind, :name, :version
 
-          def initialize(kind:, name:, version:, path:)
+          def initialize(kind:, name:, version:, path:, extra_path: nil)
+            extra_path = nil if extra_path&.empty?
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze].freeze
+            @paths = [path.dup.freeze, extra_path.dup.freeze].compact.freeze
             freeze
           end
 

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

@@ -23,6 +23,7 @@ module Datadog
           allocation_profiling_enabled:,
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
+          sighandler_sampling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -33,6 +34,9 @@ module Datadog
             Datadog.logger.warn(
               "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
+            )
           end
 
           self.class._native_initialize(
@@ -46,6 +50,7 @@ module Datadog
             allocation_profiling_enabled: allocation_profiling_enabled,
             allocation_counting_enabled: allocation_counting_enabled,
             gvl_profiling_enabled: gvl_profiling_enabled,
+            sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
           )
           @worker_thread = nil
@@ -77,6 +82,7 @@ module Datadog
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

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

@@ -41,6 +41,7 @@ module Datadog
                 "IdleSamplingHelper thread error. " \
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

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

@@ -28,6 +28,37 @@ module Datadog
 
         private
 
+        # Ruby GC tuning environment variables
+        RUBY_GC_TUNING_ENV_VARS = [
+          "RUBY_GC_HEAP_FREE_SLOTS",
+          "RUBY_GC_HEAP_GROWTH_FACTOR",
+          "RUBY_GC_HEAP_GROWTH_MAX_SLOTS",
+          "RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_MAX_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO",
+          "RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR",
+          "RUBY_GC_HEAP_REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO",
+          "RUBY_GC_MALLOC_LIMIT",
+          "RUBY_GC_MALLOC_LIMIT_MAX",
+          "RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR",
+          "RUBY_GC_OLDMALLOC_LIMIT",
+          "RUBY_GC_OLDMALLOC_LIMIT_MAX",
+          "RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR",
+          # INIT_SLOTS changed for Ruby 3.3+:
+          # * https://bugs.ruby-lang.org/issues/19785
+          # * https://www.ruby-lang.org/en/news/2023/12/25/ruby-3-3-0-released/#:~:text=Removed%20environment%20variables
+          "RUBY_GC_HEAP_0_INIT_SLOTS",
+          "RUBY_GC_HEAP_1_INIT_SLOTS",
+          "RUBY_GC_HEAP_2_INIT_SLOTS",
+          "RUBY_GC_HEAP_3_INIT_SLOTS",
+          "RUBY_GC_HEAP_4_INIT_SLOTS",
+          # There was only one setting for older Rubies:
+          "RUBY_GC_HEAP_INIT_SLOTS",
+          # Ruby 2.x only, alias for others:
+          "RUBY_FREE_MIN",
+          "RUBY_HEAP_MIN_SLOTS",
+        ].freeze
+
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
@@ -51,6 +82,7 @@ module Datadog
             engine: Datadog::Core::Environment::Identity.lang_engine,
             version: Datadog::Core::Environment::Identity.lang_version,
             platform: Datadog::Core::Environment::Identity.lang_platform,
+            gc_tuning: collect_gc_tuning_info,
           }.freeze
         end
 
@@ -109,6 +141,15 @@ module Datadog
             v.inspect
           end
         end
+
+        def collect_gc_tuning_info
+          return @gc_tuning_info if defined?(@gc_tuning_info)
+
+          @gc_tuning_info = RUBY_GC_TUNING_ENV_VARS.each_with_object({}) do |var, hash|
+            current_value = ENV[var]
+            hash[var.to_sym] = current_value if current_value
+          end.freeze
+        end
       end
     end
   end

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

@@ -21,7 +21,8 @@ module Datadog
           endpoint_collection_enabled:,
           timeline_enabled:,
           waiting_for_gvl_threshold_ns:,
-          otel_context_enabled:
+          otel_context_enabled:,
+          native_filenames_enabled:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -33,6 +34,7 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
           )
         end
 
@@ -44,6 +46,7 @@ module Datadog
           timeline_enabled: false,
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
+          native_filenames_enabled: true,
           **options
         )
           new(
@@ -54,6 +57,7 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: native_filenames_enabled,
             **options,
           )
         end
@@ -81,6 +85,17 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
+
+        def validate_native_filenames(native_filenames_enabled)
+          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
+            Datadog.logger.debug(
+              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
+            )
+            false
+          else
+            native_filenames_enabled
+          end
+        end
       end
     end
   end