cw-datadog 2.23.0.4 → 2.23.0.5

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -16,6 +16,9 @@ module Datadog
           KEY_RUN = 'datadog_grape_endpoint_run'
           KEY_RENDER = 'datadog_grape_endpoint_render'
 
+          # ✅ 优化：缓存 ENV 配置为常量，避免每次请求读取操作系统环境变量
+          CLOUDWISE_JS_ENABLED = ENV.fetch('CLOUDWISE_JS_CONFIG', 'false') == 'true'
+
           class << self
             def subscribe
               # subscribe when a Grape endpoint is hit
@@ -62,6 +65,45 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN)
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
+              # Set User-Agent
+              user_agent = env['HTTP_USER_AGENT']
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent) if user_agent
+
+              # Set base URL (scheme://host:port)
+              base_url = build_base_url_from_env(env)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL, base_url) unless base_url.empty?
+
+              # 处理 CLOUDWISEREQUESTINFO（前端调用）
+              cloudwise_info = env['HTTP_CLOUDWISEREQUESTINFO']
+              request_id = nil
+
+              if cloudwise_info
+                # 提取 request_id
+                request_id = extract_request_id(cloudwise_info)
+              end
+
+              # 如果存在 request_id，设置到 span
+              if request_id
+                span.set_tag('cwsa_trace', request_id)
+                Datadog.logger.debug do
+                  "Set cwsa_trace tag on span: #{request_id}"
+                end
+              end
+
+              # 处理 CLOUDWISE（外部服务调用，如 Java/PHP/Ruby）
+              cloudwise_header = env['HTTP_CLOUDWISE']
+
+              # 如果存在 CLOUDWISE 头（外部服务调用），提取并设置字段到 span
+              if cloudwise_header
+                require_relative '../cloudwise/propagation'
+                Cloudwise::Propagation.extract_and_tag_from_header!(span, cloudwise_header)
+              end
+
+              # 提取 CLOUDWISE-OTHER 头并添加到根 span
+              require_relative '../cloudwise/propagation'
+              Cloudwise::Propagation.extract_other_from_request!(span, env)
 
               if (grape_route = env['grape.routing_args']) && grape_route[:route_info]
                 trace.set_tag(
@@ -95,6 +137,7 @@ module Datadog
               begin
                 # collect endpoint details
                 endpoint = payload.fetch(:endpoint)
+                env = payload.fetch(:env)
                 api_view = api_view(endpoint.options[:for])
                 request_method = endpoint.options.fetch(:method).first
                 path = endpoint_expand_path(endpoint)
@@ -116,6 +159,9 @@ module Datadog
 
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request_method)
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+
+                # 处理响应头注入
+                inject_response_headers(endpoint, env, span, trace)
               ensure
                 span.start(start)
                 span.finish(finish)
@@ -235,6 +281,101 @@ module Datadog
 
             private
 
+            # 构建 base URL (scheme://host:port)
+            def build_base_url_from_env(env)
+              # 获取 scheme
+              scheme = env['rack.url_scheme'] || 'http'
+
+              # 优先使用 HTTP_HOST（可能已包含端口）
+              host = env['HTTP_HOST']
+              if host
+                # HTTP_HOST 已经包含端口（如果有的话），直接使用
+                "#{scheme}://#{host}"
+              else
+                # 回退到 SERVER_NAME + SERVER_PORT
+                host = env['SERVER_NAME'] || 'localhost'
+                port = env['SERVER_PORT']
+
+                # 只有在非标准端口时才添加端口号
+                if port && ((scheme == 'http' && port != '80') || (scheme == 'https' && port != '443'))
+                  "#{scheme}://#{host}:#{port}"
+                else
+                  "#{scheme}://#{host}"
+                end
+              end
+            rescue => e
+              Datadog.logger.debug do
+                "Error building base URL: #{e.message}"
+              end
+              ''
+            end
+
+            # 注入响应头（CLOUDWISETRACE 和 CLOUDWISE）
+            def inject_response_headers(endpoint, env, span, trace)
+
+              cloudwise_info = env['HTTP_CLOUDWISEREQUESTINFO']
+              if cloudwise_info
+                endpoint.header('CLOUDWISETRACE', 'true')
+                Datadog.logger.debug do
+                  "Added CLOUDWISETRACE response header"
+                end
+              end
+
+              # 2. 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
+              if CLOUDWISE_JS_ENABLED
+                require_relative '../cloudwise/propagation'
+
+                # 构建 CLOUDWISE 响应头值
+                service_name = Datadog.configuration.service
+                if service_name && span
+                  cloudwise_value = Cloudwise::Propagation.build_cloudwise_value(
+                    span: span,
+                    trace: trace,
+                    service_name: service_name,
+                    target_url: nil  # 响应头不需要 target_url
+                  )
+
+                  endpoint.header('CLOUDWISE', cloudwise_value)
+                  Datadog.logger.debug do
+                    "Added CLOUDWISE response header for RUM: #{cloudwise_value}"
+                  end
+                elsif service_name && span
+                  Datadog.logger.debug do
+                    "Skipped CLOUDWISE response header: Cloudwise probe suspended"
+                  end
+                end
+              end
+            rescue => e
+              Datadog.logger.error do
+                "Error injecting response headers: #{e.message}"
+              end
+            end
+
+
+            # 从 CLOUDWISEREQUESTINFO 中提取 request_id
+            def extract_request_id(cloudwise_info)
+              return nil unless cloudwise_info.is_a?(String)
+
+              # 使用正则表达式提取：第一个 _ 之后，@SDK 之前的内容（不区分大小写）
+              match = cloudwise_info.match(/_([^_@]+)@SDK/i)
+
+              if match && match[1]
+                request_id = match[1]
+                return request_id
+              else
+                Datadog.logger.debug do
+                  "Could not extract request_id from CLOUDWISEREQUESTINFO: #{cloudwise_info}"
+                end
+              end
+
+              nil
+            rescue => e
+              Datadog.logger.error do
+                "Error extracting request_id from CLOUDWISEREQUESTINFO: #{e.message}"
+              end
+              nil
+            end
+
             def handle_error(span, exception, status = nil)
               status ||= (exception.status if exception.respond_to?(:status))
               if status

data/lib/datadog/tracing/contrib/kafka/events/consumer/process_batch.rb

@@ -3,6 +3,8 @@
 require_relative '../../ext'
 require_relative '../../event'
 require_relative '../../consumer_event'
+require_relative '../../instrumentation/consumer'
+require_relative '../../../cloudwise/propagation'
 
 module Datadog
   module Tracing
@@ -31,6 +33,17 @@ module Datadog
                   span.set_tag(Ext::TAG_HIGHWATER_MARK_OFFSET, payload[:highwater_mark_offset])
                 end
                 span.set_tag(Ext::TAG_OFFSET_LAG, payload[:offset_lag]) if payload.key?(:offset_lag)
+
+                # 注意：CLOUDWISE headers 的提取移到 on_finish 中
+                # 因为 ruby-kafka 的执行顺序是：on_start -> block.call -> on_finish
+                # headers 在 block.call 中被存储到 Thread-local
+              end
+
+              # 在 span 结束时提取 CLOUDWISE headers
+              # 此时 wrapped_block 已经执行完毕，Thread-local 中有正确的 headers
+              def on_finish(span, _event, _id, _payload)
+                # 从 Thread-local 获取 CLOUDWISE headers 并提取到 span
+                extract_cloudwise_headers!(span)
               end
 
               def span_name
@@ -40,6 +53,19 @@ module Datadog
               def span_options
                 super.merge({tags: {Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_PROCESS_BATCH}})
               end
+
+              # 从 Thread-local 获取 CLOUDWISE headers 并提取到 span
+              # @param span [Datadog::Tracing::SpanOperation] 当前 span
+              def extract_cloudwise_headers!(span)
+                # 从 Thread-local 获取 consumer instrumentation 存储的 headers
+                # 使用 peek 而不是 fetch，因为可能有其他地方也需要这个 headers
+                headers = Instrumentation::Consumer.peek_cloudwise_headers
+                return unless headers
+
+                Cloudwise::Propagation.extract_kafka_cloudwise_headers!(span, headers)
+              rescue => e
+                Datadog.logger.debug("Error extracting CLOUDWISE headers from batch: #{e.class}: #{e}")
+              end
             end
           end
         end

data/lib/datadog/tracing/contrib/kafka/events/consumer/process_message.rb

@@ -3,6 +3,8 @@
 require_relative '../../ext'
 require_relative '../../event'
 require_relative '../../consumer_event'
+require_relative '../../instrumentation/consumer'
+require_relative '../../../cloudwise/propagation'
 
 module Datadog
   module Tracing
@@ -29,6 +31,17 @@ module Datadog
                 span.set_tag(Ext::TAG_PARTITION, payload[:partition]) if payload.key?(:partition)
                 span.set_tag(Ext::TAG_OFFSET, payload[:offset]) if payload.key?(:offset)
                 span.set_tag(Ext::TAG_OFFSET_LAG, payload[:offset_lag]) if payload.key?(:offset_lag)
+
+                # 注意：CLOUDWISE headers 的提取移到 on_finish 中
+                # 因为 ruby-kafka 的执行顺序是：on_start -> block.call -> on_finish
+                # headers 在 block.call 中被存储到 Thread-local
+              end
+
+              # 在 span 结束时提取 CLOUDWISE headers
+              # 此时 wrapped_block 已经执行完毕，Thread-local 中有正确的 headers
+              def on_finish(span, _event, _id, _payload)
+                # 从 Thread-local 获取 CLOUDWISE headers 并提取到 span
+                extract_cloudwise_headers!(span)
               end
 
               def span_name
@@ -38,6 +51,19 @@ module Datadog
               def span_options
                 super.merge({tags: {Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_PROCESS_MESSAGE}})
               end
+
+              # 从 Thread-local 获取 CLOUDWISE headers 并提取到 span
+              # @param span [Datadog::Tracing::SpanOperation] 当前 span
+              def extract_cloudwise_headers!(span)
+                # 从 Thread-local 获取 consumer instrumentation 存储的 headers
+                # 使用 peek 而不是 fetch，因为可能有其他地方也需要这个 headers
+                headers = Instrumentation::Consumer.peek_cloudwise_headers
+                return unless headers
+
+                Cloudwise::Propagation.extract_kafka_cloudwise_headers!(span, headers)
+              rescue => e
+                Datadog.logger.debug("Error extracting CLOUDWISE headers: #{e.class}: #{e}")
+              end
             end
           end
         end

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

@@ -1,26 +1,59 @@
 # 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
-            def self.prepended(base)
-              base.prepend(InstanceMethods)
+            # 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
 
-            # Instance methods for consumer instrumentation
-            module InstanceMethods
+            # 实例方法直接定义在模块中，会被 prepend 到 ::Kafka::Consumer
               def each_message(**kwargs, &block)
-                return super unless Datadog::DataStreams.enabled?
+              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
-                    headers = message.headers || {}
                     Datadog::DataStreams.set_consume_checkpoint(
                       type: 'kafka',
                       source: message.topic,
@@ -29,17 +62,27 @@ module Datadog
                   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)
 
-                  yield(message) if block
+                # 调用原始 block
+                original_block.call(message)
                 end
 
                 super(**kwargs, &wrapped_block)
               end
 
               def each_batch(**kwargs, &block)
-                return super unless Datadog::DataStreams.enabled?
+              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
@@ -51,12 +94,39 @@ module Datadog
                   rescue => e
                     Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
                   end
+                end
 
-                  yield(batch) if block
+                # 从批量消息的第一条消息中提取 headers 并存储到 Thread-local
+                store_batch_cloudwise_headers!(batch)
+
+                # 调用原始 block
+                original_block.call(batch)
                 end
 
                 super(**kwargs, &wrapped_block)
               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,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../cloudwise/propagation'
+
 module Datadog
   module Tracing
     module Contrib
@@ -13,13 +15,15 @@ module Datadog
 
             module InstanceMethods
               def deliver_messages(**kwargs)
-                if Datadog::DataStreams.enabled?
                   begin
                     pending_messages = instance_variable_get(:@pending_message_queue)
 
                     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,
@@ -28,20 +32,25 @@ module Datadog
                           message.headers[key] = value
                         end
                       end
+
+                      # 注入 CLOUDWISE header
+                      inject_cloudwise_headers!(message.headers, message.topic)
                     end
-                  rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
                   end
+                rescue => e
+                  Datadog.logger.debug("Error in Kafka producer instrumentation: #{e.class}: #{e}")
                 end
 
                 super
               end
 
               def send_messages(messages, **kwargs)
-                if Datadog::DataStreams.enabled?
                   begin
                     messages.each do |message|
                       message[:headers] ||= {}
+
+                    # 注入 DSM checkpoint
+                    if Datadog::DataStreams.enabled?
                       Datadog::DataStreams.set_produce_checkpoint(
                         type: 'kafka',
                         destination: message[:topic],
@@ -50,13 +59,27 @@ module Datadog
                         message[:headers][key] = value
                       end
                     end
-                  rescue => e
-                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+
+                    # 注入 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

@@ -28,6 +28,9 @@ module Datadog
         # application. If request tags are not set by the app, they will be set using
         # information available at the Rack level.
         class TraceMiddleware
+          # ✅ 优化：缓存 ENV 配置为常量，避免每次请求读取操作系统环境变量
+          CLOUDWISE_JS_ENABLED = ENV.fetch('CLOUDWISE_JS_CONFIG', 'false') == 'true'
+
           def initialize(app)
             @app = app
           end
@@ -47,7 +50,6 @@ module Datadog
               Tracing.continue_trace!(trace_digest) if trace_digest
             end
 
-          # 检查请求头中是否包含 CLOUDWISEREQUESTINFO 和 CLOUDWISE
           # 需要在创建 span 之前提取信息
           request_headers = Header::RequestHeaderCollection.new(env)
 
@@ -121,15 +123,15 @@ module Datadog
 
             # 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
             # 默认关闭，可通过环境变量 CLOUDWISE_JS_CONFIG=true 开启
-            cloudwise_js_enabled = ENV.fetch('CLOUDWISE_JS_CONFIG', 'false') == 'true'
-            if cloudwise_js_enabled
+            # 使用常量替代每次 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_active?
+              if service_name && request_span
                 cloudwise_value = Cloudwise::Propagation.build_cloudwise_value(
                   span: request_span,
                   trace: request_trace,
@@ -180,57 +182,7 @@ module Datadog
             end
           end
 
-          # Check if Cloudwise probe is active (not suspended)
-          def cloudwise_active?
-            # Try to get components from tracer first (more reliable in request context)
-            components = nil
-
-            # First try: Get components through Tracing (which accesses the tracer's @components)
-            if defined?(Datadog::Tracing) && Datadog::Tracing.respond_to?(:send)
-              tracer = Datadog::Tracing.send(:tracer) rescue nil
-              if tracer
-                components = tracer.instance_variable_get(:@components) rescue nil
-                Datadog.logger.debug { "Cloudwise active check: Got components from tracer" } if components
-              end
-            end
-
-            # Second try: Global Datadog.components
-            if components.nil? && defined?(Datadog.components)
-              components = Datadog.components rescue nil
-              Datadog.logger.debug { "Cloudwise active check: Got components from Datadog.components" } if components
-            end
-
-            unless components
-              Datadog.logger.debug { "Cloudwise active check: No components available" }
-              return false
-            end
-
-            unless components.respond_to?(:cloudwise)
-              Datadog.logger.debug { "Cloudwise active check: Components doesn't respond to cloudwise" }
-              return false
-            end
-
-            cloudwise = components.cloudwise
-            unless cloudwise&.respond_to?(:probe_state)
-              Datadog.logger.debug { "Cloudwise active check: Cloudwise doesn't respond to probe_state or is nil" }
-              return false
-            end
-
-            suspended = cloudwise.probe_state.suspended?
-            Datadog.logger.debug { "Cloudwise active check: suspended? = #{suspended}, active = #{!suspended}" }
-
-            !suspended
-          rescue => e
-            # If any error occurs, assume not active
-            Datadog.logger.debug { "Cloudwise active check error: #{e.message}" }
-            Datadog.logger.debug { e.backtrace.first(3).join("\n") } if e.backtrace
-            false
-          end
-
-          # ====== 🔥 新增：提取 request_id 的方法 ======
           # 从 CLOUDWISEREQUESTINFO 中提取 request_id
-          # 格式: ...某些内容_4fa12aec-bd00-4824-8a58-9dde05466f4a@SDK...
-          # 规则: 第一个 _ 开始，以 @SDK 结束
           def extract_request_id(cloudwise_info)
             return nil unless cloudwise_info.is_a?(String)
 

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

@@ -15,7 +15,7 @@ module Datadog
         def self.collect_and_log!(responses: nil)
           if log?
             log_configuration!('TRACING', EnvironmentCollector.collect_config!.to_json)
-            log_debug!('TRACING INTEGRATIONS', EnvironmentCollector.collect_integrations_settings!.to_json)
+            # log_debug!('TRACING INTEGRATIONS', EnvironmentCollector.collect_integrations_settings!.to_json)
 
             if responses
               err_data = EnvironmentCollector.collect_errors!(responses)

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

@@ -136,8 +136,15 @@ module Datadog
 
         # Used for serialization
         # @return [Integer] in nanoseconds since Epoch
+        # 如果启用了时间同步，会自动应用时间偏移校正
         def time_nano(time)
-          time.to_i * 1000000000 + time.nsec
+          local_time_ns = time.to_i * 1000000000 + time.nsec
+          # 应用时间同步偏移校正（如果启用且 TimeSyncWorker 已加载）
+          if defined?(Datadog::Core::Cloudwise::TimeSyncWorker)
+            Datadog::Core::Cloudwise::TimeSyncWorker.adjust_timestamp_ns(local_time_ns)
+          else
+            local_time_ns
+          end
         end
 
         def to_hash

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/environment/identity'
+require_relative '../../core/environment/process'
 require_relative '../../core/environment/socket'
 require_relative '../../core/environment/git'
 require_relative '../../core/git/ext'
@@ -63,6 +64,7 @@ module Datadog
           tag_cloudwise_metadata!
 
           if first_span
+            tag_process_tags!
             tag_git_repository_url!
             tag_git_commit_sha!
           end
@@ -260,6 +262,15 @@ module Datadog
           first_span.set_tag(Core::Git::Ext::TAG_COMMIT_SHA, git_commit_sha)
         end
 
+        def tag_process_tags!
+          return unless Datadog.configuration.experimental_propagate_process_tags_enabled
+
+          first_span.set_tag(
+            Core::Environment::Ext::TAG_PROCESS_TAGS,
+            Core::Environment::Process.serialized
+          )
+        end
+
         private
 
         def partial?

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

@@ -3,6 +3,7 @@
 require_relative '../../core/chunker'
 require_relative '../../core/transport/parcel'
 require_relative '../../core/transport/request'
+require_relative '../../core/utils/array'
 require_relative 'serializable_trace'
 require_relative 'trace_formatter'
 
@@ -65,11 +66,8 @@ module Datadog
           # @return [Enumerable[Array[Bytes,Integer]]] list of encoded chunks: each containing a byte array and
           #   number of traces
           def encode_in_chunks(traces)
-            encoded_traces = if traces.respond_to?(:filter_map)
-              # DEV Supported since Ruby 2.7, saves an intermediate object creation
-              traces.filter_map { |t| encode_one(t) }
-            else
-              traces.map { |t| encode_one(t) }.reject(&:nil?)
+            encoded_traces = Core::Utils::Array.filter_map(traces) do |trace|
+              encode_one(trace)
             end
 
             Datadog::Core::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|

data/lib/datadog/version.rb

@@ -5,7 +5,7 @@ module Datadog
     MAJOR = 2
     MINOR = 23
     PATCH = 0
-    PATCH_MINOR = 4
+    PATCH_MINOR = 5
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow