cw-datadog 2.23.0.5 → 2.23.0.6

data/lib/datadog/tracing/contrib/kafka/instrumentation/consumer.rb

@@ -1,132 +1,44 @@
 # frozen_string_literal: true
 
-require_relative '../../cloudwise/propagation'
-
 module Datadog
   module Tracing
     module Contrib
       module Kafka
         module Instrumentation
           # Instrumentation for Kafka::Consumer
-          # 这个模块直接 prepend 到 ::Kafka::Consumer，实例方法直接定义在模块中
           module Consumer
-            # Thread-local 变量用于存储当前消息的 CLOUDWISE headers
-            # 由于 ruby-kafka 的 process_message 事件在 block 调用时触发（instrument 包裹 block.call）
-            # 执行顺序是：on_start -> block.call -> on_finish
-            # 所以我们在 block 中存储 headers，在 on_finish 中提取
-            CLOUDWISE_HEADERS_KEY = :datadog_kafka_cloudwise_headers
-
-            class << self
-              # 存储当前消息的 CLOUDWISE headers 到 Thread-local
-              def store_cloudwise_headers(headers)
-                Thread.current[CLOUDWISE_HEADERS_KEY] = headers
-            end
-
-              # 获取 Thread-local 中存储的 CLOUDWISE headers（不清除）
-              # 用于 on_finish 中获取 headers
-              def peek_cloudwise_headers
-                Thread.current[CLOUDWISE_HEADERS_KEY]
-              end
-
-              # 获取并清除 Thread-local 中存储的 CLOUDWISE headers
-              def fetch_cloudwise_headers
-                headers = Thread.current[CLOUDWISE_HEADERS_KEY]
-                Thread.current[CLOUDWISE_HEADERS_KEY] = nil
-                headers
-              end
-
-              # 清除 Thread-local 中存储的 CLOUDWISE headers
-              def clear_cloudwise_headers
-                Thread.current[CLOUDWISE_HEADERS_KEY] = nil
-              end
-            end
-
-            # 实例方法直接定义在模块中，会被 prepend 到 ::Kafka::Consumer
-              def each_message(**kwargs, &block)
-              return super unless block
-
-              original_block = block
-                wrapped_block = proc do |message|
-                headers = message.headers || {}
-
-                # 处理 DSM checkpoint
-                if Datadog::DataStreams.enabled?
-                  Datadog.logger.debug { "Kafka each_message: DSM enabled for topic #{message.topic}" }
-
-                  begin
-                    Datadog::DataStreams.set_consume_checkpoint(
-                      type: 'kafka',
-                      source: message.topic,
-                      auto_instrumentation: true
-                    ) { |key| headers[key] }
-                  rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
-                  end
-                end
-
-                # 存储 CLOUDWISE headers 到 Thread-local
-                # 这会在 process_message 事件的 on_start 之后、on_finish 之前执行
-                # 所以 on_finish 可以获取到正确的 headers
-                Datadog::Tracing::Contrib::Kafka::Instrumentation::Consumer.store_cloudwise_headers(headers)
-
-                # 调用原始 block
-                original_block.call(message)
+            def each_message(**kwargs, &block)
+              if Datadog::DataStreams.enabled?
+                super do |message|
+                  headers = message.headers || {}
+
+                  Datadog::DataStreams.set_consume_checkpoint(
+                    type: 'kafka',
+                    source: message.topic,
+                    auto_instrumentation: true
+                  ) { |key| headers[key] }
+
+                  block.call(message)
                 end
-
-                super(**kwargs, &wrapped_block)
+              else
+                super
               end
+            end
 
-              def each_batch(**kwargs, &block)
-              return super unless block
-
-              original_block = block
-                wrapped_block = proc do |batch|
-                # 处理 DSM checkpoint
-                if Datadog::DataStreams.enabled?
-                  Datadog.logger.debug { "Kafka each_batch: DSM enabled for topic #{batch.topic}" }
-
-                  begin
-                    Datadog::DataStreams.set_consume_checkpoint(
-                      type: 'kafka',
-                      source: batch.topic,
-                      auto_instrumentation: true
-                    )
-                  rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
-                  end
-                end
-
-                # 从批量消息的第一条消息中提取 headers 并存储到 Thread-local
-                store_batch_cloudwise_headers!(batch)
+            def each_batch(**kwargs, &block)
+              if Datadog::DataStreams.enabled?
+                super do |batch|
+                  Datadog::DataStreams.set_consume_checkpoint(
+                    type: 'kafka',
+                    source: batch.topic,
+                    auto_instrumentation: true
+                  )
 
-                # 调用原始 block
-                original_block.call(batch)
+                  block.call(batch)
                 end
-
-                super(**kwargs, &wrapped_block)
+              else
+                super
               end
-
-            private
-
-            # 从批量消息的第一条消息中提取 headers 并存储到 Thread-local
-            # @param batch [Object] 批量消息对象
-            def store_batch_cloudwise_headers!(batch)
-              return unless batch
-
-              # 获取批量消息中的消息列表
-              messages = batch.respond_to?(:messages) ? batch.messages : nil
-              return unless messages && !messages.empty?
-
-              # 从第一条消息中提取 headers
-              first_message = messages.first
-              return unless first_message
-
-              headers = first_message.respond_to?(:headers) ? first_message.headers : nil
-              return unless headers
-
-              Datadog::Tracing::Contrib::Kafka::Instrumentation::Consumer.store_cloudwise_headers(headers)
-            rescue => e
-              Datadog.logger.debug("Error storing CLOUDWISE headers from batch: #{e.class}: #{e}")
             end
           end
         end

data/lib/datadog/tracing/contrib/kafka/instrumentation/producer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../cloudwise/propagation'
-
 module Datadog
   module Tracing
     module Contrib
@@ -15,71 +13,44 @@ module Datadog
 
             module InstanceMethods
               def deliver_messages(**kwargs)
-                  begin
-                    pending_messages = instance_variable_get(:@pending_message_queue)
+                if Datadog::DataStreams.enabled?
+                  pending_messages = instance_variable_get(:@pending_message_queue)
 
-                    if pending_messages && !pending_messages.empty?
-                      pending_messages.each do |message|
-                        message.headers ||= {}
+                  if pending_messages && !pending_messages.empty?
+                    pending_messages.each do |message|
+                      message.headers ||= {}
 
-                      # 注入 DSM checkpoint
-                      if Datadog::DataStreams.enabled?
-                        Datadog::DataStreams.set_produce_checkpoint(
-                          type: 'kafka',
-                          destination: message.topic,
-                          auto_instrumentation: true
-                        ) do |key, value|
-                          message.headers[key] = value
-                        end
+                      Datadog::DataStreams.set_produce_checkpoint(
+                        type: 'kafka',
+                        destination: message.topic,
+                        auto_instrumentation: true
+                      ) do |key, value|
+                        message.headers[key] = value
                       end
-
-                      # 注入 CLOUDWISE header
-                      inject_cloudwise_headers!(message.headers, message.topic)
                     end
                   end
-                rescue => e
-                  Datadog.logger.debug("Error in Kafka producer instrumentation: #{e.class}: #{e}")
                 end
 
                 super
               end
 
               def send_messages(messages, **kwargs)
-                  begin
-                    messages.each do |message|
-                      message[:headers] ||= {}
-
-                    # 注入 DSM checkpoint
-                    if Datadog::DataStreams.enabled?
-                      Datadog::DataStreams.set_produce_checkpoint(
-                        type: 'kafka',
-                        destination: message[:topic],
-                        auto_instrumentation: true
-                      ) do |key, value|
-                        message[:headers][key] = value
-                      end
+                if Datadog::DataStreams.enabled?
+                  messages.each do |message|
+                    message[:headers] ||= {}
+
+                    Datadog::DataStreams.set_produce_checkpoint(
+                      type: 'kafka',
+                      destination: message[:topic],
+                      auto_instrumentation: true
+                    ) do |key, value|
+                      message[:headers][key] = value
                     end
-
-                    # 注入 CLOUDWISE header
-                    inject_cloudwise_headers!(message[:headers], message[:topic])
                   end
-                rescue => e
-                  Datadog.logger.debug("Error in Kafka producer instrumentation: #{e.class}: #{e}")
                 end
 
                 super
               end
-
-              private
-
-              # 注入 CLOUDWISE headers 到 Kafka 消息
-              # @param headers [Hash] 消息 headers
-              # @param topic [String] Kafka topic 名称
-              def inject_cloudwise_headers!(headers, topic)
-                Cloudwise::Propagation.inject_kafka_headers!(headers, topic)
-              rescue => e
-                Datadog.logger.debug("Error injecting CLOUDWISE headers: #{e.class}: #{e}")
-              end
             end
           end
         end

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

@@ -29,7 +29,9 @@ module Datadog
         # information available at the Rack level.
         class TraceMiddleware
           # ✅ 优化：缓存 ENV 配置为常量，避免每次请求读取操作系统环境变量
+          # rubocop:disable CustomCops/EnvUsageCop
           CLOUDWISE_JS_ENABLED = ENV.fetch('CLOUDWISE_JS_CONFIG', 'false') == 'true'
+          # rubocop:enable CustomCops/EnvUsageCop
 
           def initialize(app)
             @app = app
@@ -50,113 +52,109 @@ module Datadog
               Tracing.continue_trace!(trace_digest) if trace_digest
             end
 
-          # 需要在创建 span 之前提取信息
-          request_headers = Header::RequestHeaderCollection.new(env)
+            # 需要在创建 span 之前提取信息
+            request_headers = Header::RequestHeaderCollection.new(env)
 
-          # 处理 CLOUDWISEREQUESTINFO（前端调用）
-          cloudwise_info = request_headers.get('CLOUDWISEREQUESTINFO')
-          request_id = nil
+            # 处理 CLOUDWISEREQUESTINFO（前端调用）
+            cloudwise_info = request_headers.get('CLOUDWISEREQUESTINFO')
+            request_id = nil
 
-          if cloudwise_info
-            # 提取 request_id
-            request_id = extract_request_id(cloudwise_info)
+            if cloudwise_info
+              # 提取 request_id
+              request_id = extract_request_id(cloudwise_info)
 
-            if request_id
-              Datadog.logger.debug do
-                "Extracted request_id from CLOUDWISEREQUESTINFO: #{request_id}"
+              if request_id
+                Datadog.logger.debug do
+                  "Extracted request_id from CLOUDWISEREQUESTINFO: #{request_id}"
+                end
               end
             end
-          end
 
-          # 处理 CLOUDWISE（外部服务调用，如 Java/PHP）
-          cloudwise_header = request_headers.get('CLOUDWISE')
+            # 处理 CLOUDWISE（外部服务调用，如 Java/PHP）
+            cloudwise_header = request_headers.get('CLOUDWISE')
 
-          TraceProxyMiddleware.call(env, configuration) do
-            trace_options = {type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND}
-            trace_options[:service] = configuration[:service_name] if configuration[:service_name]
+            TraceProxyMiddleware.call(env, configuration) do
+              trace_options = {type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND}
+              trace_options[:service] = configuration[:service_name] if configuration[:service_name]
 
-            # start a new request span and attach it to the current Rack environment;
-            # we must ensure that the span `resource` is set later
-            request_span = Tracing.trace(Ext::SPAN_REQUEST, **trace_options)
-            request_span.resource = nil
+              # start a new request span and attach it to the current Rack environment;
+              # we must ensure that the span `resource` is set later
+              request_span = Tracing.trace(Ext::SPAN_REQUEST, **trace_options)
+              request_span.resource = nil
 
-            # 如果存在 request_id，将其作为 span 的 cwsa_trace 字段
-            if request_id
-              request_span.set_tag('cwsa_trace', request_id)
-              Datadog.logger.debug do
-                "Set cwsa_trace tag on span: #{request_id}"
+              # 如果存在 request_id，将其作为 span 的 cwsa_trace 字段
+              if request_id
+                request_span.set_tag('cwsa_trace', request_id)
+                Datadog.logger.debug do
+                  "Set cwsa_trace tag on span: #{request_id}"
+                end
               end
-            end
 
-            # 如果存在 CLOUDWISE 头（外部服务调用），提取并设置字段到 span
-            if cloudwise_header
-              require_relative '../cloudwise/propagation'
-              Cloudwise::Propagation.extract_and_tag_from_header!(request_span, cloudwise_header)
-            end
+              # 如果存在 CLOUDWISE 头（外部服务调用），提取并设置字段到 span
+              if cloudwise_header
+                require_relative '../cloudwise/propagation'
+                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)
+              # 提取 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
-            env[Ext::RACK_ENV_REQUEST_SPAN] = request_span
+              # 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
+              env[Ext::RACK_ENV_REQUEST_SPAN] = request_span
 
-            Datadog::Core::Remote::Tie::Tracing.tag(boot, request_span)
+              Datadog::Core::Remote::Tie::Tracing.tag(boot, request_span)
 
-            # Copy the original env, before the rest of the stack executes.
-            # Values may change; we want values before that happens.
-            original_env = env.dup
+              # Copy the original env, before the rest of the stack executes.
+              # Values may change; we want values before that happens.
+              original_env = env.dup
 
-            # call the rest of the stack
-            status, headers, response = @app.call(env)
+              # call the rest of the stack
+              status, headers, response = @app.call(env)
 
-            # 如果存在 cloudwise_info，在响应头中添加 CLOUDWISETRACE
-            if cloudwise_info
-              headers ||= {}
-              headers['CLOUDWISETRACE'] = 'true'
-              Datadog.logger.debug do
-                "Added CLOUDWISETRACE response header"
+              # 如果存在 cloudwise_info，在响应头中添加 CLOUDWISETRACE
+              if cloudwise_info
+                headers ||= {}
+                headers['CLOUDWISETRACE'] = 'true'
+                Datadog.logger.debug do
+                  "Added CLOUDWISETRACE response header"
+                end
               end
-            end
 
-            # 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
-            # 默认关闭，可通过环境变量 CLOUDWISE_JS_CONFIG=true 开启
-            # 使用常量替代每次 ENV 读取
-            if CLOUDWISE_JS_ENABLED
-              headers ||= {}
-              require_relative '../cloudwise/propagation'
+              # 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
+              # 默认关闭，可通过环境变量 CLOUDWISE_JS_CONFIG=true 开启
+              # 使用常量替代每次 ENV 读取
+              if CLOUDWISE_JS_ENABLED
+                headers ||= {}
+                require_relative '../cloudwise/propagation'
+
+                # 构建 CLOUDWISE 响应头值
+                # Only add CLOUDWISE header if Cloudwise is active (not suspended)
+                service_name = Datadog.configuration.service
+                if service_name && request_span
+                  cloudwise_value = Cloudwise::Propagation.build_cloudwise_value(
+                    span: request_span,
+                    trace: request_trace,
+                    service_name: service_name,
+                    target_url: nil  # 响应头不需要 target_url
+                  )
 
-              # 构建 CLOUDWISE 响应头值
-              # Only add CLOUDWISE header if Cloudwise is active (not suspended)
-              service_name = Datadog.configuration.service
-              if service_name && request_span
-                cloudwise_value = Cloudwise::Propagation.build_cloudwise_value(
-                  span: request_span,
-                  trace: request_trace,
-                  service_name: service_name,
-                  target_url: nil  # 响应头不需要 target_url
-                )
-
-                headers['CLOUDWISE'] = cloudwise_value
-                Datadog.logger.debug do
-                  "Added CLOUDWISE response header for RUM: #{cloudwise_value}"
-                end
-              elsif service_name && request_span
-                Datadog.logger.debug do
-                  "Skipped CLOUDWISE response header: Cloudwise probe suspended"
+                  headers['CLOUDWISE'] = cloudwise_value
+                  Datadog.logger.debug do
+                    "Added CLOUDWISE response header for RUM: #{cloudwise_value}"
+                  end
                 end
               end
-            end
 
-            [status, headers, response]
+              [status, headers, response]
 
-            # Here we really want to catch *any* exception, not only StandardError,
-            # as we really have no clue of what is in the block,
-            # and it is user code which should be executed no matter what.
-            # It's not a problem since we re-raise it afterwards so for example a
-            # SignalException::Interrupt would still bubble up.
+              # Here we really want to catch *any* exception, not only StandardError,
+              # as we really have no clue of what is in the block,
+              # and it is user code which should be executed no matter what.
+              # It's not a problem since we re-raise it afterwards so for example a
+              # SignalException::Interrupt would still bubble up.
             rescue Exception => e # rubocop:disable Lint/RescueException
               # catch exceptions that may be raised in the middleware chain
               # Note: if a middleware catches an Exception without re raising,
@@ -205,6 +203,7 @@ module Datadog
             end
             nil
           end
+
           # rubocop:disable Metrics/AbcSize
           # rubocop:disable Metrics/CyclomaticComplexity
           # rubocop:disable Metrics/PerceivedComplexity

data/lib/datadog/tracing/tracer.rb

@@ -145,7 +145,7 @@ module Datadog
         &block
       )
         return skip_trace(name, &block) unless enabled
-        
+
         # Check Cloudwise probe state - if suspended, don't create spans
         return skip_trace(name, &block) if cloudwise_probe_suspended?
 
@@ -599,43 +599,20 @@ module Datadog
 
       # Check if Cloudwise probe is suspended
       # If suspended, we should not create any spans
+      # rubocop:disable Metrics/MethodLength
       def cloudwise_probe_suspended?
-        # First try to use the components reference passed to tracer
-        components = @components
-        
-        # If no components reference, try global Datadog.components
-        if components.nil? && defined?(Datadog.components)
-          components = Datadog.components
-        end
-        
-        unless components
-          logger.debug { "Cloudwise check: No components available" }
-          return false
-        end
-        
-        unless components.respond_to?(:cloudwise)
-          logger.debug { "Cloudwise check: Components doesn't respond to cloudwise" }
-          return false
-        end
-        
+        components = @components || (defined?(Datadog.components) && Datadog.components)
+        return false unless components&.respond_to?(:cloudwise)
+
         cloudwise = components.cloudwise
-        unless cloudwise&.enabled?
-          logger.debug { "Cloudwise check: Cloudwise not enabled or is nil" }
-          return false
-        end
-        
-        suspended = cloudwise.probe_state.suspended?
-        logger.debug { "Cloudwise check: suspended? = #{suspended}" }
-        
-        suspended
+        return false unless cloudwise&.enabled?
+
+        cloudwise.probe_state.suspended?
       rescue => e
-        # If any error occurs, don't block span creation
-        # Log error only once to avoid log spam
-        CLOUDWISE_CHECK_LOG_ONLY_ONCE.run do
-          logger.debug { "Cloudwise probe check error: #{e.message}" }
-        end
+        CLOUDWISE_CHECK_LOG_ONLY_ONCE.run { logger.debug { "Cloudwise probe check error: #{e.message}" } }
         false
       end
+      # rubocop:enable Metrics/MethodLength
 
       CLOUDWISE_CHECK_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
       private_constant :CLOUDWISE_CHECK_LOG_ONLY_ONCE

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

@@ -47,7 +47,7 @@ module Datadog
             base_path = '/api/v2/traces'
 
             return base_path unless defined?(Datadog.configuration) &&
-                                   Datadog.configuration.respond_to?(:cloudwise)
+              Datadog.configuration.respond_to?(:cloudwise)
 
             # 优先级 1: api_prefix_mode 模式配置（最高优先级，简化配置）
             if Datadog.configuration.cloudwise.respond_to?(:api_prefix_mode)
@@ -94,15 +94,13 @@ module Datadog
                 end
               end
               nil
-            else
-              nil
             end
           end
 
           # 检查是否启用 integrated_mode
           def cloudwise_integrated_mode?
             return false unless defined?(Datadog.configuration) &&
-                                Datadog.configuration.respond_to?(:cloudwise)
+              Datadog.configuration.respond_to?(:cloudwise)
 
             integrated_mode = Datadog.configuration.cloudwise.integrated_mode
             token = Datadog.configuration.cloudwise.token

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

@@ -100,7 +100,7 @@ module Datadog
                 # Add routing key header
                 env.headers['routingKey'] = 'rubyTopic'
 
-                env.headers['AccountId'] =  ENV['CLOUDWISE_ACCOUNT_ID'] || '110'
+                env.headers['AccountId'] = DATADOG_ENV['CLOUDWISE_ACCOUNT_ID'] || '110'
 
                 # Encode body & type
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
@@ -142,7 +142,7 @@ module Datadog
               def build_mock_response(env)
                 # Create a mock HTTP response
                 mock_http_response = Struct.new(:code, :payload).new(200, '{}')
-                response_options = { trace_count: env.request.parcel.trace_count }
+                response_options = {trace_count: env.request.parcel.trace_count}
                 Traces::Response.new(mock_http_response, response_options)
               end
             end

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

@@ -207,47 +207,50 @@ module Datadog
         end
 
         def tag_cloudwise_metadata!
+          # ✅ 优化：使用 set_tags 批量设置，减少锁竞争
+          tags = {}
+
           # Get all Cloudwise metadata from environment variables (set by Cloudwise client during registration)
-          account_id = ENV['CLOUDWISE_ACCOUNT_ID']
-          host_id = ENV['CLOUDWISE_HOST_ID']
-          agent_id = ENV['CLOUDWISE_AGENT_ID']
-          host_name = ENV['CLOUDWISE_HOST_NAME']
-          instance_id = ENV['CLOUDWISE_INSTANCE_ID']
-
-          # Set all metadata tags on root span
-          root_span.set_tag('account_id', account_id) if account_id && !account_id.empty?
-          root_span.set_tag('host_id', host_id) if host_id && !host_id.empty?
-          root_span.set_tag('agent_id', agent_id) if agent_id && !agent_id.empty?
-          root_span.set_tag('host_name', host_name) if host_name && !host_name.empty?
-          root_span.set_tag('instance_id', instance_id) if instance_id && !instance_id.empty?
+          account_id = DATADOG_ENV['CLOUDWISE_ACCOUNT_ID']
+          host_id = DATADOG_ENV['CLOUDWISE_HOST_ID']
+          agent_id = DATADOG_ENV['CLOUDWISE_AGENT_ID']
+          host_name = DATADOG_ENV['CLOUDWISE_HOST_NAME']
+          instance_id = DATADOG_ENV['CLOUDWISE_INSTANCE_ID']
+
+          # Collect all metadata tags
+          tags['account_id'] = account_id if account_id && !account_id.empty?
+          tags['host_id'] = host_id if host_id && !host_id.empty?
+          tags['agent_id'] = agent_id if agent_id && !agent_id.empty?
+          tags['host_name'] = host_name if host_name && !host_name.empty?
+          tags['instance_id'] = instance_id if instance_id && !instance_id.empty?
 
           # Add host_ip (server IP address)
           require_relative '../contrib/cloudwise/propagation'
           host_ip = Contrib::Cloudwise::Propagation.get_host_ip
-          root_span.set_tag('host_ip', host_ip) if host_ip && !host_ip.empty?
+          tags['host_ip'] = host_ip if host_ip && !host_ip.empty?
 
           # Generate and set app_id based on service name
           service_name = Datadog.configuration.service
           if service_name && !service_name.empty?
             app_id = Contrib::Cloudwise::Propagation.generate_app_id(service_name)
-            root_span.set_tag('app_id', app_id) if app_id
+            tags['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
+          tags['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
+          tags['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
+          # 如果 service_type_from 和 parent_sys 不存在，设置为空字符串
+          tags['service_type_from'] = '' unless root_span.get_tag('service_type_from')
+          tags['parent_sys'] = '' unless root_span.get_tag('parent_sys')
+
+          # 批量设置所有 tags
+          root_span.set_tags(tags) unless tags.empty?
         end
 
         def tag_git_repository_url!