datadog 2.42.0 → 2.43.0

data/lib/datadog/open_feature/transport.rb

@@ -8,6 +8,7 @@ require_relative "../core/transport/http/api/endpoint"
 require_relative "../core/transport/http/api/instance"
 require_relative "../core/transport/parcel"
 require_relative "../core/transport/request"
+require_relative "../version"
 
 module Datadog
   module OpenFeature
@@ -27,6 +28,8 @@ module Datadog
               request_env.headers["Content-Type"] = env.request.parcel.content_type
               request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
                 Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
               request_env.body = env.request.parcel.data
 
               block.call(request_env)
@@ -49,6 +52,8 @@ module Datadog
               request_env.headers["Content-Type"] = env.request.parcel.content_type
               request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
                 Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
               request_env.body = env.request.parcel.data
 
               block.call(request_env)

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

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require "set"
-require "time"
 require "libdatadog"
+require_relative "../../core/utils/time"
 
 module Datadog
   module Profiling
@@ -71,10 +70,7 @@ module Datadog
         # 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.
-        #
-        # Note: this does not use Core::Utils::Time.now because this constant
-        # gets initialized before a user has a chance to configure the library.
-        START_TIME = Time.now.utc.freeze
+        START_TIME = Datadog::Core::Utils::Time.now.utc.freeze
 
         #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info

data/lib/datadog/tracing/contrib/sequel/jdbc_connection_string.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Extracts connection metadata from JDBC connection strings.
+        module JDBCConnectionString
+          MAX_BYTES = 8_192
+
+          # Matches JDBC connection strings whose subname uses `[transport:]//host...`.
+          CONNECTION_STRING_PATTERN =
+            %r{\Ajdbc:[a-z][a-z0-9+.-]*:(?:[a-z][a-z0-9+.-]*:)?//(?<subname>.+)\z}im
+
+          # Extracts the host and port from a string.
+          # The host can be a multi-host value, a bracketed IPv6 host, or an ordinary host.
+          HOST_AND_PORT_PATTERN =
+            /\A(?:\[(?<ipv6_host>[^\[\]]+)\]|(?<host>[^,]+(?:,[^,]+)+|[^:]+))(?::(?<port>\d+))?\z/
+
+          DATABASE_PROPERTY_PATTERN =
+            /(?:\A|[&;])(?:databaseName|database)=(?<value>[^&;]+)/i
+          LIBRARIES_PROPERTY_PATTERN =
+            /(?:\A|[&;])libraries=,*(?<value>[^,&;]+)/i
+          DATABASE_PATH_DELIMITER_PATTERN = %r{[:@\[\]?&=#]}
+
+          private_constant :MAX_BYTES, :CONNECTION_STRING_PATTERN,
+            :DATABASE_PROPERTY_PATTERN, :LIBRARIES_PROPERTY_PATTERN,
+            :DATABASE_PATH_DELIMITER_PATTERN, :HOST_AND_PORT_PATTERN
+
+          class << self
+            # The returned Hash guarantees the existence of all keys,
+            # but Hash values can be `nil` when not parseable from the connection string.
+            #
+            # @param connection_string [String, nil] the JDBC connection string to parse
+            # @return [Hash{Symbol => String, nil}]
+            #   - `:host` — host value when the subname uses authority syntax: `//host[:port]`
+            #   - `:port` — port when the subname uses authority syntax: `//host[:port]`
+            #   - `:database` — best-effort database name
+            def parse(connection_string)
+              # @type var result: metadata
+              result = {host: nil, port: nil, database: nil}
+              return result unless connection_string.is_a?(String) && connection_string.valid_encoding?
+
+              if connection_string.bytesize > MAX_BYTES
+                # Strip userinfo before truncation. Otherwise, an `@` beyond the limit could be
+                # discarded and leave a credential prefix looking like a valid authority/host.
+                authority_marker = connection_string.index("//")
+                if authority_marker
+                  authority_start = authority_marker + 2
+                  authority_end = [
+                    connection_string.index("/", authority_start),
+                    connection_string.index(";", authority_start),
+                    connection_string.index("?", authority_start),
+                  ].compact.min || connection_string.length
+                  userinfo_end = connection_string.rindex("@", authority_end - 1)
+
+                  if userinfo_end && userinfo_end >= authority_start
+                    connection_string =
+                      # Steep: https://github.com/soutaro/steep/issues/1219
+                      connection_string[0...authority_start] + # steep:ignore NoMethod
+                      connection_string[(userinfo_end + 1)..-1].to_s
+                  end
+                end
+
+                # Keep one extra byte, then let `chop` safely remove multi-byte unicode characters.
+                if connection_string.bytesize > MAX_BYTES
+                  connection_string = connection_string.byteslice(0, MAX_BYTES + 1).chop
+                end
+              end
+
+              match = CONNECTION_STRING_PATTERN.match(connection_string)
+              return result unless match
+
+              # We start with: `host[:port][/database][;properties][?query]`.
+              subname = match[:subname]
+
+              # Extract `query` from the end, leaving `host[:port][/database][;properties]`.
+              subname, query_separator, query = subname.partition("?")
+              query = nil if query_separator.empty?
+
+              # Extract `properties` next, leaving `host[:port][/database]`.
+              subname, properties_separator, properties = subname.partition(";")
+              properties = nil if properties_separator.empty?
+
+              # Separate the authority (`host[:port]`) from the optional database path.
+              authority, path = subname.split("/", 2)
+              return result if authority.nil? || authority.empty?
+
+              host, port = host_and_port_from_authority(authority)
+              return result unless host
+
+              database = database_from_path(path) ||
+                database_from_properties(properties) || database_from_properties(query)
+
+              {host: host, port: port, database: database}
+            rescue Encoding::CompatibilityError, ArgumentError
+              result
+            end
+
+            private
+
+            def database_from_path(path)
+              return if path.nil? || path.empty?
+
+              database = path.split(DATABASE_PATH_DELIMITER_PATTERN, 2).first
+              return if database.nil? || database.empty?
+
+              database
+            end
+
+            def host_and_port_from_authority(authority)
+              # Discard optional `userinfo@`, retaining only `host[:port]`.
+              authority = authority.rpartition("@").last
+              return if authority.empty?
+
+              match = HOST_AND_PORT_PATTERN.match(authority)
+              return unless match
+
+              # Only one of `ipv6_host` or `host` will be populated.
+              host = match[:ipv6_host] || match[:host]
+              port = match[:port]
+
+              [host, port]
+            end
+
+            def database_from_properties(properties)
+              return unless properties
+
+              database = DATABASE_PROPERTY_PATTERN.match(properties)
+              return database[:value] if database
+
+              libraries = LIBRARIES_PROPERTY_PATTERN.match(properties)
+              libraries && libraries[:value]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/utils.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require "uri"
-
 require_relative "../../metadata/ext"
 require_relative "../utils/database"
 require_relative "ext"
+require_relative "jdbc_connection_string"
 require_relative "../ext"
 require_relative "../span_attribute_schema"
 
@@ -14,11 +13,6 @@ module Datadog
       module Sequel
         # General purpose functions for Sequel
         module Utils
-          JDBC_URI_PATTERN = %r{\Ajdbc:(?<vendor>[a-z][a-z0-9+.-]*):(?<location>//[^\r\n]*)\z}i
-          DATABASE_PROPERTY_PATTERN =
-            /(?:\A|[&;])(?<key>databaseName|database|libraries)=(?<value>[^&;]+)/i
-          private_constant :JDBC_URI_PATTERN, :DATABASE_PROPERTY_PATTERN
-
           class << self
             # Ruby database connector library
             #
@@ -42,34 +36,6 @@ module Datadog
               Contrib::Utils::Database.normalize_vendor(database.database_type.to_s)
             end
 
-            # Parses URI-style JDBC connection strings, extracting host, port, and
-            # (best-effort) database name. Unsupported or ambiguous forms return empty
-            # metadata rather than potentially incorrect tags.
-            def parse_jdbc_uri(uri)
-              result = {host: nil, port: nil, database: nil}
-              return result unless uri.is_a?(String) && uri.valid_encoding?
-
-              match = JDBC_URI_PATTERN.match(uri)
-              return result unless match
-
-              vendor = match[:vendor].downcase
-              location, properties = match[:location].split(";", 2)
-
-              # Several JDBC vendors append properties with semicolons, outside the URI
-              # grammar. Parse the URI-compatible location separately from those properties.
-              parsed = URI.parse("#{vendor}:#{location}")
-
-              host = parsed.hostname
-              port = parsed.port
-
-              database = database_from_path(parsed.path) ||
-                database_from_properties(properties) || database_from_properties(parsed.query)
-
-              {host: host, port: port&.to_s, database: database}
-            rescue URI::InvalidURIError, Encoding::CompatibilityError, ArgumentError
-              result
-            end
-
             def parse_opts(sql, opts, db_opts, dataset = nil)
               # Prepared statements don't provide their sql query in the +sql+ parameter.
               if !sql.is_a?(String) && dataset&.respond_to?(:prepared_sql) &&
@@ -121,25 +87,38 @@ module Datadog
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
             end
 
-            # Resolves the connection host/port/database for a Sequel::Database. When the
-            # connection string is a JDBC URL (Sequel's JDBC adapter, used on JRuby), the
-            # host/port/database are parsed from it regardless of whether opts[:host] is set.
+            # Resolves the connection host/port/database for a Sequel::Database. For Sequel's
+            # JDBC adapter (used on JRuby), metadata is parsed from the JDBC connection string
+            # regardless of whether opts[:host] is set.
             def connection_metadata(db)
               opts = db.opts || {}
               host = opts[:host]
               port = opts[:port]
               database = opts[:database]
 
-              # A JDBC URL (in :uri, :url, or :database) can carry credentials, so always parse
-              # it and emit only the parsed database name -- never the raw connection string.
-              conn = opts[:uri] || opts[:url] || opts[:database]
-              is_jdbc = conn.is_a?(String) && conn.byteslice(0, 5)&.casecmp("jdbc:") == 0
+              # A JDBC connection string (in :uri, :url, or :database) can carry credentials, so
+              # always emit only parsed metadata -- never the raw connection string.
+              connection_string = opts[:uri] || opts[:url] || opts[:database]
+              is_jdbc = connection_string.is_a?(String) &&
+                connection_string.byteslice(0, 5)&.casecmp("jdbc:") == 0
               if is_jdbc
-                parsed = parse_jdbc_uri(conn)
+                parsed = JDBCConnectionString.parse(connection_string)
+
+                # JNDI/DataSource-managed connections keep only a lookup name in opts (e.g.
+                # "jdbc:jndi:..."), so nothing can be parsed from it. Recover the endpoint from the
+                # live connection's JDBC metadata, the same way Sequel resolves JNDI. This stays a
+                # fallback rather than the primary source: it requires a connection checkout and
+                # some drivers report no connection string, whereas the opts value is free and
+                # already present for direct connections (and non-JDBC adapters have no such
+                # metadata at all).
+                if parsed[:host].nil? && parsed[:port].nil? && parsed[:database].nil?
+                  fallback_metadata = jdbc_metadata_from_connection(db)
+                  parsed = fallback_metadata if fallback_metadata
+                end
 
-                # Sequel's JDBC adapter connects with the URL and ignores separate
+                # Sequel's JDBC adapter connects with the connection string and ignores separate
                 # :host/:port options, unlike native adapters where those options take precedence.
-                if !parsed[:host].nil? || !parsed[:port].nil? || !parsed[:database].nil?
+                if parsed[:host] || parsed[:port] || parsed[:database]
                   host = parsed[:host]
                   port = parsed[:port]
                 end
@@ -151,24 +130,32 @@ module Datadog
 
             private
 
-            def database_from_path(path)
-              return unless path&.start_with?("/")
-
-              database = path[1..-1]
-              return if database.empty? || database.include?("/")
-
-              database
-            end
-
-            def database_from_properties(properties)
-              return unless properties
-
-              match = DATABASE_PROPERTY_PATTERN.match(properties)
-              return unless match
+            # Resolves host/port/database from the live connection's JDBC metadata
+            # (java.sql.DatabaseMetaData#getURL), for JNDI/DataSource connections whose opts hold
+            # only a lookup name. Returns the parsed metadata, or nil when it can't be resolved.
+            #
+            # Only *parsed, credential-free* metadata is memoized -- the raw connection string is
+            # used transiently and never stored or logged. A completed lookup that yields no usable
+            # connection string is a permanent property of the connection, so it is cached to avoid
+            # re-checking out a connection on every query. A raised error is treated as transient
+            # (pool checkout timeout, dropped connection, ...) and left uncached, so a later query
+            # can retry once connectivity recovers.
+            def jdbc_metadata_from_connection(db)
+              return db.instance_variable_get(:@datadog_jdbc_metadata) if db.instance_variable_defined?(:@datadog_jdbc_metadata)
+
+              connection_string =
+                begin
+                  db.synchronize do |conn|
+                    conn.get_meta_data.get_url if conn.respond_to?(:get_meta_data)
+                  end
+                rescue => e
+                  Datadog.logger.debug { "Sequel: unable to resolve JDBC connection metadata (#{e.class})" }
+                  return nil
+                end
 
-              database = match[:value]
-              database = database.split(",", 2).first if match[:key].casecmp("libraries").zero?
-              database
+              metadata = connection_string && JDBCConnectionString.parse(connection_string)
+              db.instance_variable_set(:@datadog_jdbc_metadata, metadata)
+              metadata
             end
 
             def datadog_configuration

data/lib/datadog/tracing/otel_thread_context.rb

@@ -24,6 +24,10 @@ module Datadog
         def set(trace_id:, span_id:, local_root_span_id:)
           _native_set(trace_id, span_id, local_root_span_id)
         end
+
+        def clear
+          _native_clear
+        end
       end
     end
   end

data/lib/datadog/tracing/transport/native.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "trace_formatter"
 require_relative "statistics"
+require_relative "span_events_negotiation"
 
 module Datadog
   module Tracing
@@ -44,6 +45,7 @@ module Datadog
         # Drop-in transport that delegates to the native trace exporter.
         class Transport
           include Statistics
+          include SpanEventsNegotiation
 
           attr_reader :logger
 
@@ -57,10 +59,6 @@ module Datadog
 
             @logger = logger
 
-            # Guards the one-shot warning about span fields the native exporter
-            # does not yet convert (see #warn_unsupported_fields!).
-            @unsupported_fields_warned = false
-
             # Serializes native sends and is held across a fork. See the
             # fork-safety note below.
             @send_mutex = Mutex.new
@@ -272,9 +270,8 @@ module Datadog
             # Each trace segment becomes one inner array (one trace chunk).
             chunks = traces.map(&:spans)
 
-            # Span events and span links are not yet converted and would be
-            # dropped. Warn (once) so the loss is visible.
-            warn_unsupported_fields!(chunks)
+            native_events_supported = native_events_supported?
+            apply_legacy_span_events!(chunks, native_events_supported)
 
             # Serialize the native send and hold the mutex across it so a
             # concurrent fork's :before hook blocks until this send drains
@@ -287,7 +284,7 @@ module Datadog
               exporter = @exporter
               raise "Native transport has been closed" if exporter.nil?
 
-              exporter._native_send_traces(chunks)
+              exporter._native_send_traces(chunks, native_events_supported)
             end
 
             # Update statistics from the response
@@ -302,29 +299,24 @@ module Datadog
 
           private
 
-          # Warn, at most once per transport, when a batch contains span fields
-          # the native exporter does not yet convert (span events and span
-          # links). These are silently dropped by the native path; full support
-          # is tracked separately. The check is cheap: the fields are already-
-          # materialized collections on each Span.
-          def warn_unsupported_fields!(chunks)
-            return if @unsupported_fields_warned
+          # Writes each span's events into the legacy JSON +events+ meta tag
+          # when the agent lacks typed-event support, mutating spans in place.
+          #
+          # @param chunks [Array<Array<Datadog::Tracing::Span>>] trace chunks to serialize
+          # @param native_events_supported [Boolean] whether the agent accepts typed events
+          # @return [void]
+          def apply_legacy_span_events!(chunks, native_events_supported)
+            return if native_events_supported
 
-            unsupported = []
             chunks.each do |spans|
               spans.each do |span|
-                unsupported << "span events" if span.events.any?
-                unsupported << "span links" if span.links.any?
+                next if span.events.empty?
+
+                span.set_tag("events", span.events.map(&:to_hash).to_json)
               end
             end
-            return if unsupported.empty?
 
-            @unsupported_fields_warned = true
-            fields = unsupported.uniq.join(", ")
-            logger.warn do
-              "Native transport does not yet support: #{fields}. This data will not be sent to Datadog. " \
-                "Unset DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED to use the default transport if you rely on these."
-            end
+            nil
           end
 
           def tracer_version_string

data/lib/datadog/tracing/transport/span_events_negotiation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Transport
+      # Shared agent capability negotiation for span event wire formats.
+      module SpanEventsNegotiation
+        private
+
+        # Queries whether the agent accepts typed span events, which selects
+        # between the typed field and legacy JSON metadata. Only successful
+        # capability responses are cached so a later flush can recover.
+        #
+        # The memo is read and written without synchronization, independent of
+        # any lock the including transport holds for its own sends (the native
+        # transport's +@send_mutex+, for example). Two concurrent sends can both
+        # observe it unset and each issue an +agent_info.fetch+; the duplicate
+        # fetch is self-correcting because the last writer wins.
+        #
+        # @return [Boolean] true if typed span events are supported
+        def native_events_supported?
+          return @native_events_supported if defined?(@native_events_supported)
+
+          option = Datadog.configuration.tracing.native_span_events
+          unless option.nil?
+            @native_events_supported = option
+            return option
+          end
+
+          components = Datadog.send(:components, allow_initialization: false)
+          return false unless components
+
+          response = components.agent_info.fetch
+          return false unless response
+
+          @native_events_supported = response.span_events == true
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/traces.rb

@@ -7,6 +7,7 @@ require_relative "../../core/transport/transport"
 require_relative "../../core/utils/enumerable_compat"
 require_relative "http/client"
 require_relative "serializable_trace"
+require_relative "span_events_negotiation"
 require_relative "trace_formatter"
 
 module Datadog
@@ -118,6 +119,7 @@ module Datadog
         # batches of traces into smaller chunks and handles
         # API version downgrade handshake.
         class Transport < Core::Transport::Transport
+          include SpanEventsNegotiation
           self.http_client_class = Tracing::Transport::HTTP::Client
 
           def send_traces(traces)
@@ -161,28 +163,6 @@ module Datadog
           def stats
             client.stats
           end
-
-          private
-
-          # Queries the agent for native span events serialization support.
-          # This changes how the serialization of span events performed.
-          def native_events_supported?
-            return @native_events_supported if defined?(@native_events_supported)
-
-            # Check for an explicit override
-            option = Datadog.configuration.tracing.native_span_events
-            unless option.nil?
-              @native_events_supported = option
-              return option
-            end
-
-            # Otherwise, check for agent support, to ensure a configuration-less setup.
-            if (res = Datadog.send(:components).agent_info.fetch)
-              @native_events_supported = res.span_events == true
-            else
-              false
-            end
-          end
         end
       end
     end

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 42
+    MINOR = 43
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.42.0
+  version: 2.43.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -1025,6 +1025,7 @@ files:
 - lib/datadog/tracing/contrib/sequel/dataset.rb
 - lib/datadog/tracing/contrib/sequel/ext.rb
 - lib/datadog/tracing/contrib/sequel/integration.rb
+- lib/datadog/tracing/contrib/sequel/jdbc_connection_string.rb
 - lib/datadog/tracing/contrib/sequel/patcher.rb
 - lib/datadog/tracing/contrib/sequel/utils.rb
 - lib/datadog/tracing/contrib/shoryuken/configuration/settings.rb
@@ -1159,6 +1160,7 @@ files:
 - lib/datadog/tracing/transport/native.rb
 - lib/datadog/tracing/transport/native/response.rb
 - lib/datadog/tracing/transport/serializable_trace.rb
+- lib/datadog/tracing/transport/span_events_negotiation.rb
 - lib/datadog/tracing/transport/statistics.rb
 - lib/datadog/tracing/transport/trace_formatter.rb
 - lib/datadog/tracing/transport/traces.rb
@@ -1172,8 +1174,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.42.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.42.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.43.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.43.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths: