cw-datadog 2.23.0.2 → 2.23.0.3

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -176,6 +176,26 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
+          # Serialize error's `locations` array as an array of Strings, given
+          # Span Events do not support hashes nested inside arrays.
+          #
+          # Here's an example in which `locations`:
+          #   [
+          #    {"line" => 3, "column" => 10},
+          #    {"line" => 7, "column" => 8},
+          #   ]
+          # is serialized as:
+          #   ["3:10", "7:8"]
+          def self.serialize_error_locations(locations)
+            # locations are only provided by the `graphql` library when the error can
+            # be associated to a particular point in the query.
+            return [] if locations.nil?
+
+            locations.map do |location|
+              "#{location["line"]}:#{location["column"]}"
+            end
+          end
+
           private
 
           # Traces the given callable with the given trace key, resource, and kwargs.
@@ -268,28 +288,13 @@ module Datadog
                   @type_key => parsed_error.type,
                   @stacktrace_key => parsed_error.backtrace,
                   @message_key => graphql_error['message'],
-                  @locations_key => serialize_error_locations(graphql_error['locations']),
+                  @locations_key =>
+                    Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.serialize_error_locations(graphql_error['locations']),
                   @path_key => graphql_error['path'],
                 )
               )
             end
           end
-
-          # Serialize error's `locations` array as an array of Strings, given
-          # Span Events do not support hashes nested inside arrays.
-          #
-          # Here's an example in which `locations`:
-          #   [
-          #    {"line" => 3, "column" => 10},
-          #    {"line" => 7, "column" => 8},
-          #   ]
-          # is serialized as:
-          #   ["3:10", "7:8"]
-          def serialize_error_locations(locations)
-            locations.map do |location|
-              "#{location["line"]}:#{location["column"]}"
-            end
-          end
         end
       end
     end

data/lib/datadog/tracing/contrib/karafka/framework.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Karafka framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          def self.setup
+            Datadog.configure do |datadog_config|
+              karafka_config = datadog_config.tracing[:karafka]
+              activate_waterdrop!(datadog_config, karafka_config)
+            end
+          end
+
+          # Apply relevant configuration from Karafka to WaterDrop
+          def self.activate_waterdrop!(datadog_config, karafka_config)
+            datadog_config.tracing.instrument(
+              :waterdrop,
+              service_name: karafka_config[:service_name],
+              distributed_tracing: karafka_config[:distributed_tracing],
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -66,6 +66,18 @@ module Datadog
           end
         end
 
+        module AppPatch
+          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          def initialized!
+            ONLY_ONCE_PER_APP[self].run do
+              # Activate tracing on components related to Karafka (e.g. WaterDrop)
+              Contrib::Karafka::Framework.setup
+            end
+            super
+          end
+        end
+
         # Patcher enables patching of 'karafka' module.
         module Patcher
           include Contrib::Patcher
@@ -78,9 +90,11 @@ module Datadog
 
           def patch
             require_relative 'monitor'
+            require_relative 'framework'
 
             ::Karafka::Instrumentation::Monitor.prepend(Monitor)
             ::Karafka::Messages::Messages.prepend(MessagesPatch)
+            ::Karafka::App.singleton_class.prepend(AppPatch)
           end
         end
       end

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

@@ -92,6 +92,10 @@ module Datadog
               Cloudwise::Propagation.extract_and_tag_from_header!(request_span, cloudwise_header)
             end
 
+            # 提取 CLOUDWISE-OTHER 头并添加到根 span
+            require_relative '../cloudwise/propagation'
+            Cloudwise::Propagation.extract_other_from_request!(request_span, request_headers)
+
             # When tracing and distributed tracing are both disabled, `.active_trace` will be `nil`,
             # Return a null object to continue operation
             request_trace = Tracing.active_trace || TraceOperation.new
@@ -116,8 +120,8 @@ module Datadog
             end
 
             # 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
-            # 默认启用，可通过环境变量 CLOUDWISE_JS_CONFIG=false 关闭
-            cloudwise_js_enabled = ENV.fetch('CLOUDWISE_JS_CONFIG', 'true') != 'false'
+            # 默认关闭，可通过环境变量 CLOUDWISE_JS_CONFIG=true 开启
+            cloudwise_js_enabled = ENV.fetch('CLOUDWISE_JS_CONFIG', 'false') == 'true'
             if cloudwise_js_enabled
               headers ||= {}
               require_relative '../cloudwise/propagation'

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Configuration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            option :service_name
+
+            option :distributed_tracing, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Distributed
+          # Extracts and injects propagation through Kafka message headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_extract_first:
+            )
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    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
+                },
+                propagation_style_inject: propagation_style_inject,
+                propagation_style_extract: propagation_style_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/ext.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_WATERDROP_ENABLED'
+
+          SPAN_PRODUCER = 'karafka.produce'
+
+          TAG_PRODUCER = 'kafka.producer'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/integration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Description of WaterDrop integration
+        class Integration
+          include Contrib::Integration
+
+          # WaterDrop added class-level instrumentation in version 2.8.8.rc1
+          MINIMUM_VERSION = Gem::Version.new('2.8.8.rc1')
+
+          register_as :waterdrop, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['waterdrop']&.version
+          end
+
+          def self.loaded?
+            !defined?(::WaterDrop).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/middleware.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Middleware to propagate tracing context in messages produced by WaterDrop
+        module Middleware
+          class << self
+            def call(message)
+              trace_op = Datadog::Tracing.active_trace
+
+              if trace_op && Datadog::Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: configuration,
+                trace: trace_op
+              )
+                WaterDrop.inject(trace_op.to_digest, message[:headers] ||= {})
+              end
+
+              if Datadog::DataStreams.enabled?
+                Datadog::DataStreams.set_produce_checkpoint(
+                  type: 'kafka',
+                  destination: message[:topic],
+                  auto_instrumentation: true
+                ) do |key, value|
+                  message[:headers] ||= {}
+                  message[:headers][key] = value
+                end
+              end
+
+              message
+            end
+
+            private
+
+            def configuration
+              Datadog.configuration.tracing[:waterdrop]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Patcher enables patching of 'waterdrop' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'producer'
+            require_relative 'middleware'
+
+            ::WaterDrop::Producer.prepend(Producer)
+            ::WaterDrop.instrumentation.subscribe('producer.configured') do |event|
+              producer = event[:producer]
+
+              included_middlewares = producer.middleware.instance_variable_get(:@steps)
+              producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+
+              if Datadog.configuration.data_streams.enabled
+                producer.monitor.subscribe('message.acknowledged') do |ack_event|
+                  if Datadog::DataStreams.enabled?
+                    payload = ack_event.payload
+                    Datadog::DataStreams.track_kafka_produce(payload[:topic], payload[:partition], payload[:offset])
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/producer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Producer integration for WaterDrop
+        module Producer
+          %i[
+            produce_many_sync
+            produce_many_async
+            produce_sync
+            produce_async
+          ].each do |method|
+            define_method(method) do |messages|
+              Datadog::Tracing.trace(Ext::SPAN_PRODUCER, resource: "waterdrop.#{__method__}") do
+                extract_span_tags(messages)
+                super(messages)
+              end
+            end
+          end
+
+          private
+
+          def extract_span_tags(messages)
+            messages = [messages] if messages.is_a?(Hash)
+            span = Datadog::Tracing.active_span
+            return unless span
+
+            topics = []
+            partitions = []
+            messages.each do |message|
+              topics << message[:topic]
+              partitions << message[:partition] if message.key?(:partition)
+            end
+
+            span.set_tag(Ext::TAG_PRODUCER, id)
+            span.set_tag(Contrib::Karafka::Ext::TAG_MESSAGE_COUNT, messages.size)
+            span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Contrib::Karafka::Ext::TAG_SYSTEM)
+
+            span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, topics.uniq.sort.join(','))
+            span.set_tag(Contrib::Karafka::Ext::TAG_PARTITION, partitions.uniq.sort.join(',')) if partitions.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'waterdrop/integration'
+require_relative 'waterdrop/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `WaterDrop` integration public API
+      module WaterDrop
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('waterdrop') do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = WaterDrop::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -55,6 +55,7 @@ require_relative 'contrib/httpclient/integration'
 require_relative 'contrib/httprb/integration'
 require_relative 'contrib/integration'
 require_relative 'contrib/kafka/integration'
+require_relative 'contrib/waterdrop'
 require_relative 'contrib/karafka'
 require_relative 'contrib/lograge/integration'
 require_relative 'contrib/mongodb/integration'

data/lib/datadog/tracing/transport/http/api.rb

@@ -21,10 +21,13 @@ module Datadog
           module_function
 
           def defaults
+            # 获取 traces V4 路径（动态根据配置决定）
+            v4_traces_path = get_traces_v4_path
+
             Core::Transport::HTTP::API::Map[
               V4 => Traces::API::Spec.new do |s|
                 s.traces = Traces::API::Endpoint.new(
-                  '/api/v2/traces',
+                  v4_traces_path,
                   Core::Encoding::MsgpackEncoder,
                   service_rates: true
                 )
@@ -37,6 +40,42 @@ module Datadog
               end,
             ].with_fallbacks(V4 => V3)
           end
+
+          # 获取 Traces V4 API 路径
+          # 优先级：DD_CLOUDWISE_API_PREFIX > integrated_mode > 默认
+          def get_traces_v4_path
+            base_path = '/api/v2/traces'
+
+            # 优先级 1: 显式配置的 api_prefix（最高优先级）
+            if defined?(Datadog.configuration) &&
+               Datadog.configuration.respond_to?(:cloudwise) &&
+               Datadog.configuration.cloudwise.respond_to?(:api_prefix)
+              api_prefix = Datadog.configuration.cloudwise.api_prefix
+              if api_prefix && !api_prefix.empty?
+                prefix = api_prefix.start_with?('/') ? api_prefix : "/#{api_prefix}"
+                return "#{prefix}#{base_path}"
+              end
+            end
+
+            # 优先级 2: integrated_mode 使用 /apm 前缀
+            if cloudwise_integrated_mode?
+              return "/apm#{base_path}"
+            end
+
+            # 优先级 3: 无前缀（默认）
+            base_path
+          end
+
+          # 检查是否启用 integrated_mode
+          def cloudwise_integrated_mode?
+            return false unless defined?(Datadog.configuration) &&
+                                Datadog.configuration.respond_to?(:cloudwise)
+
+            integrated_mode = Datadog.configuration.cloudwise.integrated_mode
+            token = Datadog.configuration.cloudwise.token
+
+            integrated_mode && token && !token.empty?
+          end
         end
       end
     end

data/lib/datadog/tracing/transport/http/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'statistics'
+require_relative '../../../core/transport/http/client'
 require_relative '../../../core/transport/http/env'
 require_relative '../../../core/transport/http/response'
 
@@ -9,33 +10,24 @@ module Datadog
     module Transport
       module HTTP
         # Routes, encodes, and sends tracer data to the trace agent via HTTP.
-        class Client
+        class Client < Core::Transport::HTTP::Client
           include Datadog::Tracing::Transport::HTTP::Statistics
 
-          attr_reader :api, :logger
+          private
 
-          def initialize(api, logger: Datadog.logger)
-            @api = api
-            @logger = logger
-          end
-
-          def send_request(request, &block)
-            # Build request into env
-            env = build_env(request)
-
-            # Get responses from API
-            response = yield(api, env)
+          def on_response(response)
+            super
 
             # Update statistics
             update_stats_from_response!(response)
+          end
 
-            response
-          rescue => e
-            message =
-              "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
+          def on_exception(exception)
+            # Note: this method does NOT call super - it has replacement
+            # logic for how to log the exception.
+
+            message = build_exception_message(exception)
 
-            # Log error
             if stats.consecutive_errors > 0
               logger.debug(message)
             else
@@ -44,13 +36,7 @@ module Datadog
             end
 
             # Update statistics
-            update_stats_from_exception!(e)
-
-            Datadog::Core::Transport::InternalErrorResponse.new(e)
-          end
-
-          def build_env(request)
-            Datadog::Core::Transport::HTTP::Env.new(request)
+            update_stats_from_exception!(exception)
           end
         end
       end

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

@@ -100,6 +100,8 @@ module Datadog
                 # Add routing key header
                 env.headers['routingKey'] = 'rubyTopic'
 
+                env.headers['AccountId'] =  ENV['CLOUDWISE_ACCOUNT_ID'] || '110'
+
                 # Encode body & type
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
                 env.body = env.request.parcel.data
@@ -126,10 +128,10 @@ module Datadog
                 # Check if Cloudwise component exists and probe is suspended
                 return false unless defined?(Datadog.components)
                 return false unless Datadog.components.respond_to?(:cloudwise)
-                
+
                 cloudwise = Datadog.components.cloudwise
                 return false unless cloudwise&.enabled?
-                
+
                 cloudwise.probe_state.suspended?
               rescue => e
                 # If any error occurs, don't block trace submission

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

@@ -230,6 +230,22 @@ module Datadog
             app_id = Contrib::Cloudwise::Propagation.generate_app_id(service_name)
             root_span.set_tag('app_id', app_id) if app_id
           end
+
+          # Add new Cloudwise fields: service_instance_id, service_type_from, parent_sys, sys
+          # Generate service_instance_id based on IP + process path + PID
+          service_instance_id = Contrib::Cloudwise::Propagation.generate_service_instance_id
+          root_span.set_tag('service_instance_id', service_instance_id) if service_instance_id
+
+          # Get sys from environment variable (default: 'default')
+          sys = Contrib::Cloudwise::Propagation.get_sys
+          root_span.set_tag('sys', sys) if sys
+
+          unless root_span.get_tag('service_type_from')
+            root_span.set_tag('service_type_from', '')
+          end
+          unless root_span.get_tag('parent_sys')
+            root_span.set_tag('parent_sys', '')
+          end
         end
 
         def tag_git_repository_url!

data/lib/datadog/version.rb

@@ -5,7 +5,7 @@ module Datadog
     MAJOR = 2
     MINOR = 23
     PATCH = 0
-    PATCH_MINOR = 2
+    PATCH_MINOR = 3
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow
@@ -22,6 +22,6 @@ module Datadog
     # To allow testing with the next unreleased version of Ruby, the version check is performed
     # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
     # but not stable MAXIMUM_RUBY_VERSION releases.
-    MAXIMUM_RUBY_VERSION = '3.5'
+    MAXIMUM_RUBY_VERSION = '4.0'
   end
 end

data/lib/datadog.rb

@@ -9,6 +9,7 @@ require_relative 'datadog/profiling'
 require_relative 'datadog/appsec'
 require_relative 'datadog/di'
 require_relative 'datadog/data_streams'
+require_relative 'datadog/open_feature'
 
 # 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