datadog 2.40.0 → 2.41.0

data/lib/datadog/tracing/contrib/rack/patcher.rb

@@ -70,7 +70,7 @@ module Datadog
         module Patcher
           PATCHERS = [
             MiddlewarePatcher,
-            MiddlewareNamePatcher
+            MiddlewareNamePatcher,
           ].freeze
 
           module_function

data/lib/datadog/tracing/contrib/rack/trace_proxy_middleware.rb

@@ -27,7 +27,7 @@ module Datadog
             options = {
               service: configuration[:web_service_name],
               start_time: start_time,
-              type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY
+              type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY,
             }
 
             request_span = Tracing.trace(Ext::SPAN_HTTP_PROXY_REQUEST, **options)

data/lib/datadog/tracing/contrib/redis/configuration/resolver.rb

@@ -34,7 +34,7 @@ module Datadog
                 host: hash[:host],
                 port: hash[:port],
                 db: hash[:db],
-                scheme: hash[:scheme]
+                scheme: hash[:scheme],
               }
             end
 

data/lib/datadog/tracing/contrib/redis/quantize.rb

@@ -15,6 +15,9 @@ module Datadog
 
           AUTH_COMMANDS = %w[AUTH auth].freeze
 
+          CONNECTION_SETUP_COMMANDS = Set.new(%w[HELLO]).freeze
+          CLIENT_CONNECTION_SETUP_SUBCOMMANDS = Set.new(%w[SETINFO SETNAME]).freeze
+
           MULTI_VERB_COMMANDS = Set.new(
             %w[
               ACL
@@ -40,7 +43,7 @@ module Datadog
 
           def format_command_args(command_args)
             command_args = resolve_command_args(command_args)
-            return "AUTH ?" if auth_command?(command_args)
+            return "AUTH ?" if auth_command?(command_args) || hello_auth_command?(command_args)
 
             verb, *args = command_args.map { |x| format_arg(x) }
             Core::Utils.truncate("#{verb.upcase} #{args.join(" ")}", CMD_MAX_LEN, TOO_LONG_MARK)
@@ -51,6 +54,8 @@ module Datadog
 
             return get_verb(command_args.first) if command_args.first.is_a?(Array)
 
+            return "AUTH" if hello_auth_command?(command_args)
+
             verb = command_args.first.to_s.upcase
             return verb unless MULTI_VERB_COMMANDS.include?(verb) && command_args[1]
 
@@ -64,6 +69,35 @@ module Datadog
             AUTH_COMMANDS.include?(verb)
           end
 
+          # Identifies a RESP3 `HELLO ... AUTH user pass` handshake command, which embeds
+          # credentials the same way a standalone `AUTH` command does and must be redacted
+          # (and kept visible as its own span) rather than treated as a silent connection
+          # bootstrap command.
+          def hello_auth_command?(command_args)
+            return false unless command_args.is_a?(Array) && !command_args.empty?
+
+            # `redis-client` always emits this as `["HELLO", "3", "AUTH", username, password]` — check
+            # the fixed "AUTH" keyword position only, never the username/password values themselves,
+            # since those are untrusted, possibly-binary bulk strings that `#upcase` can raise on.
+            return false if command_args.length < 3
+            command_args[0].to_s.upcase == "HELLO" && command_args[2].to_s.upcase == "AUTH"
+          end
+
+          # Identifies protocol-level connection bootstrap commands (`HELLO`, `CLIENT SETINFO`,
+          # `CLIENT SETNAME`) that `redis-client` sends as part of its per-connection handshake,
+          # so they can be excluded from pipeline resource naming. A `HELLO` carrying `AUTH`
+          # credentials is excluded from this so authentication remains visible as its own span.
+          def connection_setup_command?(command_args)
+            command_args = resolve_command_args(command_args)
+            return false unless command_args.is_a?(Array) && !command_args.empty?
+            return false if hello_auth_command?(command_args)
+
+            verb = command_args.first.to_s.upcase
+            return true if CONNECTION_SETUP_COMMANDS.include?(verb)
+
+            verb == "CLIENT" && CLIENT_CONNECTION_SETUP_SUBCOMMANDS.include?(command_args[1].to_s.upcase)
+          end
+
           # Unwraps command array when Redis is called with the following syntax:
           #   redis.call([:cmd, 'arg1', ...])
           def resolve_command_args(command_args)
@@ -72,7 +106,7 @@ module Datadog
             command_args
           end
 
-          private_class_method :auth_command?, :resolve_command_args
+          private_class_method :auth_command?, :hello_auth_command?, :resolve_command_args
         end
       end
     end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb

@@ -37,12 +37,18 @@ module Datadog
             end
 
             def call_pipelined(client, commands, service_name, command_args)
+              # `redis-client` sends its per-connection handshake (`HELLO`, `CLIENT SETINFO`/`SETNAME`)
+              # as a pipeline through this same code path. Excluding those from resource naming keeps
+              # the resource focused on application-issued commands (e.g. a lone `SELECT` prelude).
+              traced_commands = commands.reject { |c| Contrib::Redis::Quantize.connection_setup_command?(c) }
+              return yield if traced_commands.empty? && !commands.empty?
+
               Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
                 span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Redis::Ext::TAG_COMPONENT)
-                raw_command = get_pipeline_commands(commands, true)
-                span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
+                raw_command = get_pipeline_commands(traced_commands, true)
+                span.resource = command_args ? raw_command : get_pipeline_commands(traced_commands, false)
 
-                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, traced_commands.length
 
                 Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
 

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

@@ -84,7 +84,7 @@ module Datadog
                 query: sql,
                 prepared_name: prepared_name,
                 database: db_opts[:database],
-                host: db_opts[:host]
+                host: db_opts[:host],
               }
             end
 

data/lib/datadog/tracing/contrib/sidekiq/distributed/propagation.rb

@@ -35,7 +35,7 @@ module Datadog
                     Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
                     Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
-                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new,
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,

data/lib/datadog/tracing/contrib/sinatra/configuration/settings.rb

@@ -12,7 +12,7 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             DEFAULT_HEADERS = {
-              response: %w[Content-Type X-Request-ID]
+              response: %w[Content-Type X-Request-ID],
             }.freeze
 
             option :enabled do |o|

data/lib/datadog/tracing/contrib/sneakers/tracer.rb

@@ -18,7 +18,7 @@ module Datadog
             trace_options = {
               service: configuration[:service_name],
               type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
-              on_error: configuration[:on_error]
+              on_error: configuration[:on_error],
             }
 
             Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|

data/lib/datadog/tracing/contrib/utils/quantization/hash_formatter.rb

@@ -15,7 +15,7 @@ module Datadog
             DEFAULT_OPTIONS = { # steep:ignore IncompatibleAssignment
               exclude: EXCLUDE_KEYS,
               show: SHOW_KEYS,
-              placeholder: PLACEHOLDER
+              placeholder: PLACEHOLDER,
             }.freeze
 
             module_function

data/lib/datadog/tracing/contrib/waterdrop/distributed/propagation.rb

@@ -34,7 +34,7 @@ module Datadog
                     Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
                     Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
-                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new,
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,

data/lib/datadog/tracing/correlation.rb

@@ -51,9 +51,9 @@ module Datadog
               service: service.to_s,
               version: version.to_s,
               trace_id: trace_id.to_s,
-              span_id: span_id.to_s
+              span_id: span_id.to_s,
             },
-            ddsource: Core::Logging::Ext::DD_SOURCE
+            ddsource: Core::Logging::Ext::DD_SOURCE,
           }
         end
 

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -47,7 +47,7 @@ module Datadog
 
           def collect_errors!(responses)
             {
-              agent_error: agent_error(responses)
+              agent_error: agent_error(responses),
             }
           end
 
@@ -114,7 +114,7 @@ module Datadog
               {
                 name: rule.matcher.name,
                 service: rule.matcher.service,
-                sample_rate: rule.sampler.sample_rate(nil)
+                sample_rate: rule.sampler.sample_rate(nil),
               }
             end.compact
           end

data/lib/datadog/tracing/distributed/baggage.rb

@@ -231,8 +231,7 @@ module Datadog
           tags = {}
 
           baggage_tag_keys.each do |key, _|
-            # Steep: https://github.com/soutaro/steep/issues/2031
-            value = baggage[key] # steep:ignore ArgumentTypeMismatch
+            value = baggage[key]
             next if value.nil? || value.empty?
 
             tags["baggage.#{key}"] = value

data/lib/datadog/tracing/metadata/tagging.rb

@@ -21,7 +21,7 @@ module Datadog
           Ext::Distributed::TAG_ORIGIN => true,
           Core::Environment::Ext::TAG_VERSION => true,
           Ext::HTTP::TAG_STATUS_CODE => true,
-          Ext::NET::TAG_HOSTNAME => true
+          Ext::NET::TAG_HOSTNAME => true,
         }.freeze
 
         # Return the tag with the given key, nil if it doesn't exist.

data/lib/datadog/tracing/remote.rb

@@ -37,9 +37,9 @@ module Datadog
             # Guard for RBS/Steep
             raise "option is a #{option.class}, expected Option" unless option.is_a?(Configuration::Dynamic::Option)
 
-            option.call(value)
+            telemetry_value = option.call(value)
 
-            [env_var, value]
+            [env_var, telemetry_value]
           end
 
           if (di_enabled = lib_config["dynamic_instrumentation_enabled"]) != nil # rubocop:disable Style/NonNilCheck

data/lib/datadog/tracing/span.rb

@@ -157,7 +157,7 @@ module Datadog
           span_id: @id,
           trace_id: @trace_id,
           type: @type,
-          span_links: @links.map(&:to_hash)
+          span_links: @links.map(&:to_hash),
         }
 
         if stopped?

data/lib/datadog/tracing/span_operation.rb

@@ -346,7 +346,7 @@ module Datadog
           resource: @resource,
           service: @service,
           trace_id: @trace_id,
-          type: @type
+          type: @type,
         }
 
         if stopped?

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

@@ -27,7 +27,7 @@ module Datadog
             ENCODED_IDS = [
               :trace_id,
               :span_id,
-              :parent_id
+              :parent_id,
             ].freeze
 
             # Encodes a list of traces

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

@@ -65,6 +65,10 @@ module Datadog
             # fork-safety note below.
             @send_mutex = Mutex.new
 
+            # Serializes concurrent fork-hook lifecycles. Unlike @send_mutex,
+            # this is held across the fork through the matching completion hook.
+            @fork_mutex = Mutex.new
+
             url = agent_settings.url
             tracer_version = tracer_version_string
             language = Core::Environment::Ext::LANG
@@ -106,8 +110,15 @@ module Datadog
             # also tears down and replaces the runtime, so it must not run while
             # a send is still using that runtime.
             #
-            # `@send_mutex` serializes sends (see #send_traces) and is held
-            # across the fork. The `:before` hook first calls
+            # `@fork_mutex` serializes concurrent forks for this exporter. The
+            # `:before` hook locks it first, then calls `_native_before_fork`,
+            # and finally locks `@send_mutex`, which serializes sends and is
+            # held across the fork. Sends and #close only acquire @send_mutex,
+            # so there is no lock-order inversion.
+            #
+            # `_native_before_fork` must run before locking `@send_mutex` to
+            # pause the runtime before waiting for an in-flight send to drain.
+            # The hook first calls
             # `_native_before_fork` to pause the runtime, THEN locks the mutex.
             # This ordering minimizes the serialized section and is safe to run
             # concurrently with an in-flight send: `block_on` (used by
@@ -136,25 +147,29 @@ module Datadog
             # hooks when it goes away (see #close and the finalizer): otherwise
             # the closures keep the exporter -- and its runtime threads -- alive
             # forever, and every later fork runs them against every
-            # historically-created exporter. The closures intentionally capture
-            # only the `exporter`/`send_mutex` locals (NOT `self`), so the
-            # Transport stays GC-eligible and its finalizer can fire even when
-            # #close was not called explicitly.
+            # historically-created exporter. The closures intentionally close
+            # over only locals (NOT `self`), so the Transport stays GC-eligible and
+            # its finalizer can fire even when #close was not called explicitly.
             send_mutex = @send_mutex
-            before_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:before) do
-              # Pause the runtime first (safe to run concurrently with an
-              # in-flight send), then drain by locking the mutex. The lock must
-              # happen even if `_native_before_fork` raises, so the in-flight
-              # send has returned (dropping the runtime's last `Arc`) before the
-              # fork. Held across the fork; released in :parent/:child.
-              exporter._native_before_fork
-            rescue => e
-              Datadog.logger.warn { "Native transport before-fork preparation failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
-            ensure
-              send_mutex.lock
+            fork_mutex = @fork_mutex
+            before_hook = proc do
+              fork_mutex.lock
+
+              begin
+                # Pause the runtime first (safe to run concurrently with an
+                # in-flight send), then wait for it to drain by acquiring the
+                # mutex. The lock must happen even if `_native_before_fork` raises, so the
+                # in-flight send has returned before the fork. Held across the
+                # fork; released in :parent/:child.
+                exporter._native_before_fork
+              rescue => e
+                Datadog.logger.warn { "Native transport before-fork preparation failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
+              ensure
+                send_mutex.lock
+              end
             end
-            parent_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:parent) do
-              exporter._native_after_fork_in_parent
+            parent_hook = proc do
+              exporter._native_after_fork_in_parent if fork_mutex.owned?
             rescue => e
               Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
             ensure
@@ -164,9 +179,10 @@ module Datadog
               # between `_native_before_fork` and the lock). Released even if the
               # native call raised, so a failure can't leave the mutex locked.
               send_mutex.unlock if send_mutex.owned?
+              fork_mutex.unlock if fork_mutex.owned?
             end
-            child_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
-              exporter._native_after_fork_in_child
+            child_hook = proc do
+              exporter._native_after_fork_in_child if fork_mutex.owned?
             rescue => e
               Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
             ensure
@@ -174,61 +190,70 @@ module Datadog
               # lone survivor in the child); the guard only covers `:before`
               # being interrupted mid-lock.
               send_mutex.unlock if send_mutex.owned?
+              fork_mutex.unlock if fork_mutex.owned?
             end
 
-            @fork_hooks = {before: before_hook, parent: parent_hook, child: child_hook}
+            @fork_hooks = Core::Utils::AtForkMonkeyPatch.at_fork_blocks(
+              before: before_hook,
+              parent: parent_hook,
+              child: child_hook
+            )
+            remove_fork_hooks = self.class.send(:fork_hooks_remover, @fork_hooks)
 
             # Fallback so a dropped (un-#close'd) transport doesn't leak its
             # global fork hooks (and, through them, the exporter/runtime). The
-            # finalizer proc is built by a class method capturing ONLY the
+            # removal proc is built by a class method capturing ONLY the
             # stage->block handles, never `self` -- a finalizer that closed over
             # the object it is attached to would keep that object reachable and
-            # never run.
-            ObjectSpace.define_finalizer(self, self.class.send(:finalizer_for, @fork_hooks))
+            # never run. A fork that already copied these callbacks still owns
+            # them through its matching completion stage.
+            ObjectSpace.define_finalizer(
+              self,
+              remove_fork_hooks
+            )
           end
 
           # Deregister this transport's process-global fork hooks and release the
           # native exporter so its runtime can shut down. Idempotent: safe to
           # call multiple times and safe to call after the finalizer has run.
           def close
-            fork_hooks = @fork_hooks
-            @fork_hooks = nil
-            return if fork_hooks.nil?
+            fork_hooks = @send_mutex.synchronize do
+              hooks = @fork_hooks
+              return if hooks.nil?
+
+              @fork_hooks = nil
+              @exporter = nil
+              hooks
+            end
 
             fork_hooks.each do |stage, block|
               Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
             end
 
-            # Drop our reference to the exporter so that, once the hooks above no
-            # longer pin it, it can be collected and its runtime shut down
-            # cleanly in this (parent) process.
-            @exporter = nil
-
             # The finalizer only exists to deregister the hooks for a transport
             # dropped without #close. We have just done that, so remove it;
-            # otherwise its captured hook blocks keep the exporter (and its
-            # runtime threads) alive until this still-reachable transport is
-            # itself collected.
+            # otherwise its closed-over hook blocks keep the exporter alive until
+            # this transport is itself collected.
             ObjectSpace.undefine_finalizer(self)
 
             nil
           end
 
-          # Builds the finalizer proc for a transport's fork hooks.
+          # Builds the proc that deregisters a transport's fork hooks.
           #
           # Defined as a class method so the proc closes over ONLY the
           # stage->block handles passed in and never over a Transport instance
           # (which would keep the instance reachable and prevent the finalizer
           # from ever running). Removing the hooks unpins the exporter captured
           # by those closures, allowing it (and its runtime) to be freed.
-          def self.finalizer_for(fork_hooks)
+          def self.fork_hooks_remover(fork_hooks)
             proc do
               fork_hooks.each do |stage, block|
                 Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
               end
             end
           end
-          private_class_method :finalizer_for
+          private_class_method :fork_hooks_remover
 
           # Send a list of traces to the agent.
           #
@@ -240,12 +265,6 @@ module Datadog
           def send_traces(traces)
             return [] if traces.empty?
 
-            # A closed transport has released its exporter; there is nothing to
-            # send through. Raising here is caught below and surfaced as an
-            # InternalErrorResponse, matching the other failure paths.
-            exporter = @exporter
-            raise "Native transport has been closed" if exporter.nil?
-
             # Apply trace-level tags to root spans (same as the HTTP transport)
             traces.each { |trace| TraceFormatter.format!(trace) }
 
@@ -253,9 +272,8 @@ module Datadog
             # Each trace segment becomes one inner array (one trace chunk).
             chunks = traces.map(&:spans)
 
-            # The native exporter only serializes scalar fields plus meta and
-            # metrics; span events, span links, and meta_struct are not yet
-            # converted and would be dropped. Warn (once) so the loss is visible.
+            # Span events and span links are not yet converted and would be
+            # dropped. Warn (once) so the loss is visible.
             warn_unsupported_fields!(chunks)
 
             # Serialize the native send and hold the mutex across it so a
@@ -263,7 +281,14 @@ module Datadog
             # (and `_native_before_fork` cannot tear down the runtime mid-send).
             # `Mutex#synchronize` releases on exception / `rb_jump_tag` via its
             # ensure, so interrupt propagation stays correct.
-            responses = @send_mutex.synchronize { exporter._native_send_traces(chunks) }
+            responses = @send_mutex.synchronize do
+              # Resolve the exporter under the same lock used by #close, so
+              # close either drains this send or prevents it from starting.
+              exporter = @exporter
+              raise "Native transport has been closed" if exporter.nil?
+
+              exporter._native_send_traces(chunks)
+            end
 
             # Update statistics from the response
             responses.each { |response| update_stats_from_response!(response) }
@@ -278,10 +303,10 @@ module Datadog
           private
 
           # Warn, at most once per transport, when a batch contains span fields
-          # the native exporter does not yet convert (span events, span links,
-          # meta_struct). 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.
+          # 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
 
@@ -290,7 +315,6 @@ module Datadog
               spans.each do |span|
                 unsupported << "span events" if span.events.any?
                 unsupported << "span links" if span.links.any?
-                unsupported << "meta_struct" unless span.metastruct.to_h.empty?
               end
             end
             return if unsupported.empty?

data/lib/datadog/tracing/writer.rb

@@ -130,7 +130,7 @@ module Datadog
       def stats
         {
           traces_flushed: @traces_flushed,
-          transport: @transport.stats
+          transport: @transport.stats,
         }
       end
 

data/lib/datadog/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.40.0
+  version: 2.41.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -63,14 +63,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 36.0.0.1.0
+        version: 40.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 36.0.0.1.0
+        version: 40.0.0.1.0
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -432,6 +432,7 @@ files:
 - lib/datadog/core/tag_builder.rb
 - lib/datadog/core/tag_normalizer.rb
 - lib/datadog/core/telemetry/component.rb
+- lib/datadog/core/telemetry/configuration_value.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/event/app_client_configuration_change.rb
@@ -1165,8 +1166,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.40.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.40.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.41.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.41.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths: