cw-datadog 2.23.0.2

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

@@ -0,0 +1,475 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative '../../../core/environment/variable_helpers'
+require_relative '../../../core/remote/tie/tracing'
+require_relative '../../client_ip'
+require_relative '../../metadata/ext'
+require_relative '../http'
+require_relative '../analytics'
+require_relative '../utils/quantization/http'
+require_relative 'ext'
+require_relative 'header_collection'
+require_relative 'header_tagging'
+require_relative 'request_queue'
+require_relative 'route_inference'
+require_relative 'trace_proxy_middleware'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Rack module includes middlewares that are required to trace any framework
+      # and application built on top of Rack.
+      module Rack
+        # TraceMiddleware ensures that the Rack Request is properly traced
+        # from the beginning to the end. The middleware adds the request span
+        # in the Rack environment so that it can be retrieved by the underlying
+        # application. If request tags are not set by the app, they will be set using
+        # information available at the Rack level.
+        class TraceMiddleware
+          def initialize(app)
+            @app = app
+          end
+
+          def call(env)
+            # Find out if this is rack within rack
+            previous_request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+
+            return @app.call(env) if previous_request_span
+
+            boot = Datadog::Core::Remote::Tie.boot
+
+            # Extract distributed tracing context before creating any spans,
+            # so that all spans will be added to the distributed trace.
+            if configuration[:distributed_tracing]
+              trace_digest = Contrib::HTTP.extract(env)
+              Tracing.continue_trace!(trace_digest) if trace_digest
+            end
+
+          # 检查请求头中是否包含 CLOUDWISEREQUESTINFO 和 CLOUDWISE
+          # 需要在创建 span 之前提取信息
+          request_headers = Header::RequestHeaderCollection.new(env)
+
+          # 处理 CLOUDWISEREQUESTINFO（前端调用）
+          cloudwise_info = request_headers.get('CLOUDWISEREQUESTINFO')
+          request_id = nil
+
+          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}"
+              end
+            end
+          end
+
+          # 处理 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]
+
+            # 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}"
+              end
+            end
+
+            # 如果存在 CLOUDWISE 头（外部服务调用），提取并设置字段到 span
+            if cloudwise_header
+              require_relative '../cloudwise/propagation'
+              Cloudwise::Propagation.extract_and_tag_from_header!(request_span, cloudwise_header)
+            end
+
+            # 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)
+
+            # 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)
+
+            # 如果存在 cloudwise_info，在响应头中添加 CLOUDWISETRACE
+            if cloudwise_info
+              headers ||= {}
+              headers['CLOUDWISETRACE'] = 'true'
+              Datadog.logger.debug do
+                "Added CLOUDWISETRACE response header"
+              end
+            end
+
+            # 如果启用了 CLOUDWISE_JS_CONFIG，在响应头中添加 CLOUDWISE（用于 RUM 追踪）
+            # 默认启用，可通过环境变量 CLOUDWISE_JS_CONFIG=false 关闭
+            cloudwise_js_enabled = ENV.fetch('CLOUDWISE_JS_CONFIG', 'true') != 'false'
+            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?
+                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"
+                end
+              end
+            end
+
+            [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.
+            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,
+              # the Exception cannot be recorded here.
+              request_span&.set_error(e)
+              raise e
+            ensure
+              env[Ext::RACK_ENV_REQUEST_SPAN] = previous_request_span if previous_request_span
+
+              if request_span
+                # Rack is a really low level interface and it doesn't provide any
+                # advanced functionality like routers. Because of that, we assume that
+                # the underlying framework or application has more knowledge about
+                # the result for this request; `resource` and `tags` are expected to
+                # be set in another level but if they're missing, reasonable defaults
+                # are used.
+                set_request_tags!(request_trace, request_span, env, status, headers, response, original_env || env)
+
+                # ensure the request_span is finished and the context reset;
+                # this assumes that the Rack middleware creates a root span
+                request_span.finish
+              end
+            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)
+
+            # 使用正则表达式提取：第一个 _ 之后，@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
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/MethodLength
+          def set_request_tags!(trace, request_span, env, status, headers, response, original_env)
+            request_header_collection = Header::RequestHeaderCollection.new(env)
+
+            # Since it could be mutated, it would be more accurate to fetch from the original env,
+            # e.g. ActionDispatch::ShowExceptions middleware with Rails exceptions_app configuration
+            original_request_method = original_env['REQUEST_METHOD']
+
+            # request_headers is subject to filtering and configuration so we
+            # get the user agent separately
+            user_agent = parse_user_agent_header(request_header_collection)
+
+            # The priority
+            # 1. User overrides span.resource
+            # 2. Configuration
+            # 3. Nested App override trace.resource
+            # 4. Fallback with verb + status, eq `GET 200`
+            request_span.resource ||=
+              if configuration[:middleware_names] && env['RESPONSE_MIDDLEWARE']
+                "#{env["RESPONSE_MIDDLEWARE"]}##{original_request_method}"
+              elsif trace.resource_override?
+                trace.resource
+              else
+                "#{original_request_method} #{status}".strip
+              end
+
+            # Overrides the trace resource if it never been set
+            # Otherwise, the getter method would delegate to its root span
+            trace.resource = request_span.resource unless trace.resource_override?
+
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
+            set_route_and_endpoint_tags(trace: trace, request_span: request_span, status: status, env: env)
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(request_span)
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD).nil?
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, original_request_method)
+            end
+
+            url = parse_url(env, original_env)
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_URL).nil?
+              options = configuration[:quantize] || {}
+
+              # Quantization::HTTP.url base defaults to :show, but we are transitioning
+              options[:base] ||= :exclude
+
+              request_span.set_tag(
+                Tracing::Metadata::Ext::HTTP::TAG_URL,
+                Contrib::Utils::Quantization::HTTP.url(url, options)
+              )
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL).nil?
+              options = configuration[:quantize]
+
+              unless options[:base] == :show
+                base_url = Contrib::Utils::Quantization::HTTP.base_url(url)
+
+                unless base_url.empty?
+                  request_span.set_tag(
+                    Tracing::Metadata::Ext::HTTP::TAG_BASE_URL,
+                    base_url
+                  )
+                end
+              end
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP).nil?
+              Tracing::ClientIp.set_client_ip_tag(
+                request_span,
+                headers: request_header_collection,
+                remote_ip: env['REMOTE_ADDR']
+              )
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE).nil? && status
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status)
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT).nil? && user_agent
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
+            end
+
+            HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
+            HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
+
+            # detect if the status code is a 5xx and flag the request span as an error
+            # unless it has been already set by the underlying framework
+            if request_span.status.zero? && Datadog.configuration.tracing.http_error_statuses.server.include?(status)
+              request_span.status = Tracing::Metadata::Ext::Errors::STATUS
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/MethodLength
+
+          private
+
+          def configuration
+            Datadog.configuration.tracing[:rack]
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          def set_route_and_endpoint_tags(trace:, request_span:, status:, env:)
+            return if status == 404
+
+            if (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # This happens when processing requests to a nested rack application,
+              # when parent app is instrumented, and the nested app is not instrumented
+              #
+              # When resource_renaming.always_simplified_endpoint is set to true,
+              # we infer the route from the full request path.
+              if last_script_name == '' && env['SCRIPT_NAME'] != '' &&
+                  !Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint &&
+                  (inferred_route = RouteInference.infer(env['PATH_INFO']))
+                set_endpoint_tag(request_span, last_route + inferred_route)
+              end
+
+              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+
+              # Ensure tags are placed in rack.request span as desired
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
+              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+            end
+
+            if Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint ||
+                request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil?
+              if (inferred_route = RouteInference.read_or_infer(env))
+                set_endpoint_tag(request_span, inferred_route) if inferred_route
+              end
+            elsif !request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT)
+              set_endpoint_tag(request_span, request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def set_endpoint_tag(request_span, value)
+            # In the first iteration, http.endpoint must be reported in 2 cases:
+            #   1. resource renaming is enabled
+            #   2. AppSec is enabled and resource renaming is disabled (by default, not explicitly)
+            if Datadog.configuration.tracing.resource_renaming.enabled ||
+                Datadog.configuration.appsec.enabled && Datadog.configuration.tracing.resource_renaming.options[:enabled].default_precedence?
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT, value)
+            end
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          def parse_url(env, original_env)
+            request_obj = ::Rack::Request.new(env)
+
+            # scheme, host, and port
+            base_url = if request_obj.respond_to?(:base_url)
+              request_obj.base_url
+            else
+              # Compatibility for older Rack versions
+              request_obj.url.chomp(request_obj.fullpath)
+            end
+
+            # https://github.com/rack/rack/blob/main/SPEC.rdoc
+            #
+            # The source of truth in Rack is the PATH_INFO key that holds the
+            # URL for the current request; but some frameworks may override that
+            # value, especially during exception handling.
+            #
+            # Because of this, we prefer to use REQUEST_URI, if available, which is the
+            # relative path + query string, and doesn't mutate.
+            #
+            # REQUEST_URI is only available depending on what web server is running though.
+            # So when its not available, we want the original, unmutated PATH_INFO, which
+            # is just the relative path without query strings.
+            #
+            # SCRIPT_NAME is the first part of the request URL path, so that
+            # the application can know its virtual location. It should be
+            # prepended to PATH_INFO to reflect the correct user visible path.
+            request_uri = env['REQUEST_URI'].to_s
+            fullpath = if request_uri.empty?
+              query_string = original_env['QUERY_STRING'].to_s
+              path = original_env['SCRIPT_NAME'].to_s + original_env['PATH_INFO'].to_s
+
+              query_string.empty? ? path : "#{path}?#{query_string}"
+            else
+              # normally REQUEST_URI starts at the path, but it
+              # might contain the full URL in some cases (e.g WEBrick)
+              request_uri.delete_prefix(base_url)
+            end
+
+            base_url + fullpath
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+
+          def parse_user_agent_header(headers)
+            headers.get(Tracing::Metadata::Ext::HTTP::HEADER_USER_AGENT)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # Provides instrumentation for `rack`
+        module MiddlewarePatcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            # Patch middleware
+            require_relative 'middlewares'
+          end
+        end
+
+        # Provides instrumentation for Rack middleware names
+        module MiddlewareNamePatcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_middleware_names
+          end
+
+          def patch_middleware_names
+            retain_middleware_name(get_option(:application))
+          rescue => e
+            # We can safely ignore these exceptions since they happen only in the
+            # context of middleware patching outside a Rails server process (eg. a
+            # process that doesn't serve HTTP requests but has Rails environment
+            # loaded such as a Resque master process)
+            Datadog.logger.debug("Error patching middleware stack: #{e}")
+          end
+
+          def retain_middleware_name(middleware)
+            return unless middleware&.respond_to?(:call)
+
+            middleware.singleton_class.class_eval do
+              alias_method :__call, :call
+
+              def call(env)
+                env['RESPONSE_MIDDLEWARE'] = self.class.to_s
+                __call(env)
+              end
+            end
+
+            following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
+
+            retain_middleware_name(following)
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:rack].get_option(option)
+          end
+        end
+
+        # Applies multiple patches
+        module Patcher
+          PATCHERS = [
+            MiddlewarePatcher,
+            MiddlewareNamePatcher
+          ].freeze
+
+          module_function
+
+          def patched?
+            PATCHERS.all?(&:patched?)
+          end
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            MiddlewarePatcher.patch unless MiddlewarePatcher.patched?
+
+            # Patch middleware names
+            if !MiddlewareNamePatcher.patched? && get_option(:middleware_names)
+              if get_option(:application)
+                MiddlewareNamePatcher.patch
+              else
+                Datadog.logger.warn(
+                  %(
+                Rack :middleware_names requires you to also pass :application.
+                Middleware names have NOT been patched; please provide :application.
+                e.g. use: :rack, middleware_names: true, application: my_rack_app)
+                )
+              end
+            end
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:rack].get_option(option)
+          end
+
+          def patch_successful
+            MiddlewarePatcher.patch_successful || MiddlewareNamePatcher.patch_successful
+          end
+
+          def patch_error_result
+            MiddlewarePatcher.patch_error_result || MiddlewareNamePatcher.patch_error_result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # Retrieves the time spent in an upstream proxy
+        # for the current Rack request.
+        #
+        # This time captures the request delay introduced but
+        # such proxy before the request made it to the Ruby
+        # process.
+        module QueueTime
+          REQUEST_START = 'HTTP_X_REQUEST_START'
+          QUEUE_START = 'HTTP_X_QUEUE_START'
+          MINIMUM_ACCEPTABLE_TIME_VALUE = 1_000_000_000
+
+          module_function
+
+          def get_request_start(env, now = Core::Utils::Time.now.utc)
+            header = env[REQUEST_START] || env[QUEUE_START]
+            return unless header
+
+            # nginx header is seconds in the format "t=1512379167.574"
+            # apache header is microseconds in the format "t=1570633834463123"
+            # heroku header is milliseconds in the format "1570634024294"
+            # @see https://github.com/heroku/vegur/blob/65d168f757e0ddb448f41cfb9e4b0281c747378d/README.md?plain=1#L383-L384
+            time_string = header.to_s.delete('^0-9')
+            return if time_string.nil?
+
+            # Return nil if the time is clearly invalid
+            time_value = "#{time_string[0, 10]}.#{time_string[10, 6]}".to_f
+            return if time_value.zero? || time_value < MINIMUM_ACCEPTABLE_TIME_VALUE
+
+            # return the request_start only if it's lesser than
+            # current time, to avoid significant clock skew
+            request_start = Time.at(time_value)
+            (request_start.utc > now) ? nil : request_start
+          rescue => e
+            # in case of an Exception we don't create a
+            # `request.queuing` span
+            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
+            nil
+          end
+        end
+      end
+    end
+  end
+end