cw-datadog 2.23.0.2 → 2.23.0.4

data/lib/datadog/tracing/contrib/cloudwise/propagation.rb

@@ -14,6 +14,11 @@ module Datadog
         class Propagation
           TYPE_FROM = 'RUBY'
           HEADER_NAME = 'CLOUDWISE'
+          HEADER_OTHER_NAME = 'CLOUDWISE-OTHER'
+
+          # 服务类型
+          SERVICE_TYPE_APPLICATION = 'APPLICATION'
+          SERVICE_TYPE_TASK = 'task'
 
           # CLOUDWISE 字段索引
           FIELD_TYPE_FROM = 0
@@ -27,6 +32,10 @@ module Datadog
           FIELD_SEGMENT_ID = 8
           FIELD_APP_NAME = 9
 
+          # CLOUDWISE-OTHER 字段索引
+          FIELD_OTHER_SERVICE_TYPE_FROM = 0
+          FIELD_OTHER_PARENT_SYS = 1
+
           # 注入 CLOUDWISE 请求头
           # @param span [Datadog::Tracing::SpanOperation] 当前 span
           # @param trace [Datadog::Tracing::TraceOperation] 当前 trace
@@ -41,6 +50,9 @@ module Datadog
             # 获取目标 URL
             target_url = extract_target_url(request)
 
+            # 生成 assumed_app_id
+            assumed_app_id = generate_assumed_app_id(target_url)
+
             # 构建 CLOUDWISE header 值
             cloudwise_value = build_cloudwise_value(
               span: span,
@@ -52,6 +64,14 @@ module Datadog
             # 添加到请求头
             request[HEADER_NAME] = cloudwise_value if cloudwise_value
 
+            # 注入 CLOUDWISE-OTHER 请求头
+            inject_other_header!(request)
+
+            # 将 assumed_app_id 添加到 span 的 tags 中
+            if assumed_app_id && assumed_app_id != '-1'
+              span.set_tag('assumed_app_id', assumed_app_id)
+            end
+
             Datadog.logger.debug do
               "Injected CLOUDWISE header: #{cloudwise_value}"
             end if defined?(Datadog.logger)
@@ -257,8 +277,7 @@ module Datadog
             span.set_tag('app_name_from', fields[:app_name]) if fields[:app_name]
 
             Datadog.logger.debug do
-              "Extracted CLOUDWISE header fields: type_from=#{fields[:type_from]}, " \
-              "app_id_from=#{fields[:app_id]}, app_name_from=#{fields[:app_name]}"
+              "Extracted CLOUDWISE header : cloudwise_header=#{cloudwise_header}"
             end if defined?(Datadog.logger)
           rescue => e
             Datadog.logger.error do
@@ -288,17 +307,17 @@ module Datadog
               return nil
             end
 
-            # 构建字段哈希
+            # 构建字段哈希（将 "null" 字符串转换为空字符串）
             {
               type_from: parts[FIELD_TYPE_FROM]&.strip,
-              sample: parts[FIELD_SAMPLE]&.strip,
-              host_id: parts[FIELD_HOST_ID]&.strip,
+              sample: normalize_field_value(parts[FIELD_SAMPLE]),
+              host_id: normalize_field_value(parts[FIELD_HOST_ID]),
               app_id: parts[FIELD_APP_ID]&.strip,
-              instance_id: parts[FIELD_INSTANCE_ID]&.strip,
+              instance_id: normalize_field_value(parts[FIELD_INSTANCE_ID]),
               trace_id: parts[FIELD_TRACE_ID]&.strip,
               assumed_app_id: parts[FIELD_ASSUMED_APP_ID]&.strip,
               span_id: parts[FIELD_SPAN_ID]&.strip,
-              segment_id: parts[FIELD_SEGMENT_ID]&.strip,
+              segment_id: normalize_field_value(parts[FIELD_SEGMENT_ID]),
               app_name: parts[FIELD_APP_NAME]&.strip
             }
           rescue => e
@@ -307,6 +326,144 @@ module Datadog
             end if defined?(Datadog.logger)
             nil
           end
+
+          # 标准化字段值：去除空格，将 "null" 转换为空字符串
+          # @param value [String, nil] 原始字段值
+          # @return [String] 标准化后的字段值
+          def self.normalize_field_value(value)
+            return '-1' if value.nil?
+
+            normalized = value.strip
+            # 将字符串 "null" 转换为空字符串
+            normalized == 'null' ? '-1' : normalized
+          end
+
+          # 获取当前服务的 sys 值
+          # @return [String] sys 值，默认为 'default'
+          def self.get_sys
+            ENV['CW_SYS'] || 'default'
+          end
+
+          # 生成 service_instance_id（基于 IP + 进程路径 + PID）
+          # @return [String] service_instance_id
+          def self.generate_service_instance_id
+            host_ip = get_host_ip
+            process_path = $PROGRAM_NAME || ''
+            process_pid = Process.pid.to_s
+
+            # 组合：IP + 进程路径 + PID
+            combined = "#{host_ip}#{process_path}#{process_pid}"
+
+            # 使用 MD5 生成唯一 ID
+            require 'digest/md5'
+            md5_hex = Digest::MD5.hexdigest(combined)
+            # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+            md5_hex[0..14].to_i(16).to_s
+          rescue => e
+            Datadog.logger.debug { "Error generating service_instance_id: #{e.message}" } if defined?(Datadog.logger)
+            # 降级方案：使用 PID
+            Process.pid.to_s
+          end
+
+          # 检测当前服务类型
+          # @return [String] 服务类型：'APPLICATION' 或 'task'
+          def self.detect_service_type
+            # 优先检查环境变量显式设置
+            service_type_env = ENV['CLOUDWISE_SERVICE_TYPE']
+            if service_type_env
+              return SERVICE_TYPE_TASK if service_type_env.downcase == 'task'
+              return SERVICE_TYPE_APPLICATION if service_type_env.downcase == 'application'
+            end
+
+            # 检查是否在 Worker 进程中运行（更精确的判断）
+            # Sidekiq Worker 进程（检查 Sidekiq 是否作为服务器运行）
+            if defined?(::Sidekiq) && ::Sidekiq.respond_to?(:server?) && ::Sidekiq.server?
+              return SERVICE_TYPE_TASK
+            end
+
+            # Resque Worker 进程
+            if defined?(::Resque) && ENV['QUEUE']
+              return SERVICE_TYPE_TASK
+            end
+
+            # DelayedJob Worker 进程
+            if defined?(::Delayed::Worker) && ENV['DELAYED_JOB']
+              return SERVICE_TYPE_TASK
+            end
+
+            # 显式的 Worker 模式
+            if ENV['WORKER_MODE'] == 'true'
+              return SERVICE_TYPE_TASK
+            end
+
+            # 默认为 Web 应用
+            SERVICE_TYPE_APPLICATION
+          rescue => e
+            # 如果检测出错，默认为 Web 应用
+            Datadog.logger.debug { "Error detecting service type: #{e.message}, defaulting to APPLICATION" } if defined?(Datadog.logger)
+            SERVICE_TYPE_APPLICATION
+          end
+
+          # 注入 CLOUDWISE-OTHER 请求头到下游服务
+          # @param request [Net::HTTPRequest] HTTP 请求对象
+          def self.inject_other_header!(request)
+            return unless request
+
+            service_type = detect_service_type
+            sys = get_sys
+
+            # 构建 CLOUDWISE-OTHER 值：service_type_from:sys
+            other_value = "#{service_type}:#{sys}"
+            request[HEADER_OTHER_NAME] = other_value
+
+            Datadog.logger.debug do
+              "Injected CLOUDWISE-OTHER header: #{other_value}"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error injecting CLOUDWISE-OTHER header: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 从请求头中提取 CLOUDWISE-OTHER 并添加到根 span
+          # @param span [Datadog::Tracing::SpanOperation] 根 span
+          # @param request_headers [Hash] 请求头
+          def self.extract_other_from_request!(span, request_headers)
+            return unless span
+
+            # 从请求头中获取 CLOUDWISE-OTHER
+            other_header = request_headers[HEADER_OTHER_NAME] ||
+                          request_headers['HTTP_' + HEADER_OTHER_NAME.upcase.gsub('-', '_')]
+
+            if other_header
+              # 解析 CLOUDWISE-OTHER：service_type_from:parent_sys
+              parts = other_header.split(':')
+
+              service_type_from = normalize_field_value(parts[FIELD_OTHER_SERVICE_TYPE_FROM])
+              parent_sys = normalize_field_value(parts[FIELD_OTHER_PARENT_SYS])
+
+              # 只添加上游相关的字段到 span tags
+              # sys 和 service_instance_id 将在 tag_cloudwise_metadata! 中设置
+              span.set_tag('service_type_from', service_type_from)
+              span.set_tag('parent_sys', parent_sys)
+
+              Datadog.logger.debug do
+                "Extracted CLOUDWISE-OTHER from request: service_type_from=#{service_type_from}, parent_sys=#{parent_sys}"
+              end if defined?(Datadog.logger)
+            else
+              # 如果没有上游请求头，设置为空字符串
+              span.set_tag('service_type_from', '')
+              span.set_tag('parent_sys', '')
+
+              Datadog.logger.debug do
+                "No CLOUDWISE-OTHER header in request, set service_type_from and parent_sys to empty"
+              end if defined?(Datadog.logger)
+            end
+          rescue => e
+            Datadog.logger.error do
+              "Error extracting CLOUDWISE-OTHER: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
         end
       end
     end

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