datadog 2.8.0 → 2.39.0

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -17,9 +17,9 @@ module Datadog
           unless setter == ::OpenTelemetry::Context::Propagation.text_map_setter
             # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
-              'Custom setter is not supported. Please inform the `datadog` team at ' \
-            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
-            'OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter.'
+              "Custom setter is not supported. Please inform the `datadog` team at " \
+            " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
+            "OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter."
             )
           end
 
@@ -35,29 +35,38 @@ module Datadog
             # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
               "Custom getter #{getter} is not supported. Please inform the `datadog` team at " \
-            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
-            'OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.'
+            " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
+            "OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter."
             )
           end
 
           digest = @datadog_propagator.extract(carrier)
           return context unless digest
 
+          # Always call continue_trace! so span links are created in restart mode
+          # (when digest.trace_id is nil) before we attempt to build the OTel SpanContext.
+          trace = Tracing.continue_trace!(digest)
+
+          # In restart mode DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT=restart, the extracted
+          # digest carries no trace_id (fresh start). continue_trace! has already recorded
+          # the span link; return the current context so the caller's span starts a new root.
+          return context unless digest.trace_id
+
           # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
           # 128-bit unsigned, big-endian integer
-          trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack('Q>Q>')
+          trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack("Q>Q>")
           # 64-bit unsigned, big-endian integer
-          span_id = [digest.span_id].pack('Q>')
+          span_id = [digest.span_id].pack("Q>")
 
           if digest.trace_state || digest.trace_flags
             trace_flags = ::OpenTelemetry::Trace::TraceFlags.from_byte(digest.trace_flags)
             tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
           else
             trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
-                            ::OpenTelemetry::Trace::TraceFlags::SAMPLED
-                          else
-                            ::OpenTelemetry::Trace::TraceFlags::DEFAULT
-                          end
+              ::OpenTelemetry::Trace::TraceFlags::SAMPLED
+            else
+              ::OpenTelemetry::Trace::TraceFlags::DEFAULT
+            end
             tracestate = ::OpenTelemetry::Trace::Tracestate::DEFAULT
           end
 
@@ -70,9 +79,6 @@ module Datadog
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)
-
-          trace = Tracing.continue_trace!(digest)
-
           span.datadog_trace = trace
 
           ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'trace/span'
-require_relative '../../tracing/span_link'
-require_relative '../../tracing/span_event'
-require_relative '../../tracing/trace_digest'
+require_relative "trace/span"
+require_relative "../../core/utils"
+require_relative "../../tracing/span_link"
+require_relative "../../tracing/span_event"
+require_relative "../../tracing/trace_digest"
 
 module Datadog
   module OpenTelemetry
@@ -101,12 +102,14 @@ module Datadog
 
           unless span.links.nil?
             datadog_span.links = span.links.map do |link|
+              tracestate = link.span_context.tracestate&.to_s
+
               Datadog::Tracing::SpanLink.new(
                 Datadog::Tracing::TraceDigest.new(
                   trace_id: link.span_context.hex_trace_id.to_i(16),
                   span_id: link.span_context.hex_span_id.to_i(16),
                   trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
-                  trace_state: link.span_context.tracestate&.to_s,
+                  trace_state: tracestate && ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil),
                   span_remote: link.span_context.remote?,
                 ),
                 attributes: link.attributes
@@ -119,29 +122,29 @@ module Datadog
 
         # Some special attributes can override Datadog Span fields
         def span_arguments(span, attributes)
-          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
-            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          if attributes.key?("analytics.event") && (analytics_event = attributes["analytics.event"]).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = (analytics_event.casecmp("true") == 0) ? 1 : 0
           end
 
-          if attributes.key?('http.response.status_code')
-            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete('http.response.status_code')
+          if attributes.key?("http.response.status_code")
+            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete("http.response.status_code")
           end
 
-          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || "internal"
 
-          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+          kwargs = {start_time: ns_to_time(span.start_timestamp)}
 
-          name = if attributes.key?('operation.name')
-                   attributes['operation.name']
-                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
-                   rich_name.downcase
-                 else
-                   span.kind
-                 end
+          name = if attributes.key?("operation.name")
+            attributes["operation.name"]
+          elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+            rich_name.downcase
+          else
+            span.kind
+          end
 
-          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
-          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
-          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+          kwargs[:resource] = attributes.key?("resource.name") ? attributes["resource.name"] : span.name
+          kwargs[:service] = attributes["service.name"] if attributes.key?("service.name")
+          kwargs[:type] = attributes["span.type"] if attributes.key?("span.type")
 
           attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
 

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,22 +30,22 @@ 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
         end
 
-        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
-        alias []= set_attribute
+        # `alias` performed to match {::OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute # rubocop:disable Style/Alias
 
         # Attributes are equivalent to span tags and metrics.
         def add_attributes(attributes)
           res = super
           # Attributes can get dropped or their values truncated by `super`
-          attributes.each { |key, _| datadog_set_attribute(key) }
+          attributes.each_key { |key| datadog_set_attribute(key) }
           res
         end
 
@@ -67,50 +67,50 @@ 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']}"
+            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']
-              return "aws.#{service || 'client'}.request"
+          if attrs.key?("rpc.system")
+            if attrs["rpc.system"] == "aws-api" && kind == :client
+              service = attrs["rpc.service"]
+              return "aws.#{service || "client"}.request"
             end
 
             if kind == :client
-              return "#{attrs['rpc.system']}.client.request"
+              return "#{attrs["rpc.system"]}.client.request"
             elsif kind == :server
-              return "#{attrs['rpc.system']}.server.request"
+              return "#{attrs["rpc.system"]}.server.request"
             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
@@ -119,6 +119,7 @@ module Datadog
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def datadog_set_attribute(key)
           # Return if attributes are currently disabled by OpenTelemetry.
           return unless defined?(@attributes) && @attributes
@@ -128,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
 
@@ -142,34 +143,37 @@ 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
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
         # Some special attributes can override Datadog Span fields beyond tags and metrics.
         # @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
@@ -15,10 +15,10 @@ module Datadog
         # @return [TraceOperation]
         def start_trace_copy(trace, parent_span: nil)
           digest = if parent_span
-                     digest_with_parent_span(trace, parent_span)
-                   else
-                     trace.to_digest
-                   end
+            digest_with_parent_span(trace, parent_span)
+          else
+            trace.to_digest
+          end
 
           # Create a new TraceOperation, attached to the current Datadog Tracer.
           Datadog::Tracing.continue_trace!(digest)

data/lib/datadog/opentelemetry.rb

@@ -9,17 +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/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/logs" if defined?(OpenTelemetry::SDK::Logs)
 
 module Datadog
   # Datadog OpenTelemetry integration.
@@ -29,7 +33,7 @@ module Datadog
 
     # Use `Datadog.logger` as the default logger
     def logger
-      @logger ||= ::Datadog.logger
+      ::Datadog.logger
     end
 
     ::OpenTelemetry.singleton_class.prepend(self)
@@ -46,6 +50,7 @@ end
 # Currently, this closely translates to Datadog's partial flushing.
 #
 # @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+
 Datadog.configure do |c|
   c.tracing.partial_flush.enabled = true
 end

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

@@ -14,11 +14,18 @@ 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"))
+        # @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
+        )
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
           @seen_libraries = Set.new
+          @executable_paths = [Gem.bindir, bundler_bin_path].uniq.compact.freeze
 
           record_library(
             Library.new(
@@ -26,10 +33,14 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
+              extra_paths: [ruby_native_filename],
             )
           )
         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)
@@ -37,22 +48,20 @@ module Datadog
           self
         end
 
-        def generate
-          seen_libraries
-        end
-
+        #: () -> ::String
         def generate_json
-          JSON.fast_generate(v1: seen_libraries.to_a)
+          JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
 
-        attr_reader \
-          :libraries_by_name,
-          :libraries_by_path,
-          :seen_files,
-          :seen_libraries
+        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
@@ -69,23 +78,41 @@ 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
 
           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))
+            extra_paths = [(spec.extension_dir if spec.extensions.any?)]
+            spec.executables&.each do |executable|
+              executable_paths.each do |path|
+                extra_paths << File.join(path, executable)
+              end
+            end
+
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_paths: extra_paths,
+              )
+            )
             recorded_library = true
           end
 
           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)
@@ -99,6 +126,31 @@ module Datadog
           end
         end
 
+        # This is intended to mirror bundler's `Bundler.bin_path` with one key difference: the bundler version of the
+        # method **tries to create the path** if it doesn't exist, whereas our version doesn't.
+        #
+        # This "try to create the path" is annoying because creating the path can fail if e.g. the app doesn't have
+        # permissions to do that, see https://github.com/DataDog/dd-trace-rb/issues/5137.
+        # Thus we have our own version that a) Avoids creating the path, and b) Rescues exceptions to avoid any
+        # 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)
+
+          path = Bundler.settings[:bin] || "bin"
+          root = Bundler.root
+          result = Pathname.new(path).expand_path(root).expand_path
+          result.to_s
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.debug(
+            "CodeProvenance#bundler_bin_path failed. " \
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          nil
+        end
+
         # Represents metadata we have for a ruby gem
         #
         # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
@@ -108,20 +160,36 @@ 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
-
-          def initialize(kind:, name:, version:, path:)
+          # @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
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze].freeze
+            @paths = [path.dup.freeze, *extra_paths].freeze
             freeze
           end
 
+          #: (?::JSON::State?) -> ::String
           def to_json(arg = nil)
             {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
+          #: () -> ::String
           def path
             @paths.first
           end