cw-datadog 2.23.0.2

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'socket'
+require 'uri'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Cloudwise
+        # Cloudwise 分布式追踪传播器
+        # 用于在 Ruby 服务调用 Java 服务时添加 CLOUDWISE 请求头
+        # 以及处理外部服务调用 Ruby 时的 CLOUDWISE 请求头
+        class Propagation
+          TYPE_FROM = 'RUBY'
+          HEADER_NAME = 'CLOUDWISE'
+
+          # CLOUDWISE 字段索引
+          FIELD_TYPE_FROM = 0
+          FIELD_SAMPLE = 1
+          FIELD_HOST_ID = 2
+          FIELD_APP_ID = 3
+          FIELD_INSTANCE_ID = 4
+          FIELD_TRACE_ID = 5
+          FIELD_ASSUMED_APP_ID = 6
+          FIELD_SPAN_ID = 7
+          FIELD_SEGMENT_ID = 8
+          FIELD_APP_NAME = 9
+
+          # 注入 CLOUDWISE 请求头
+          # @param span [Datadog::Tracing::SpanOperation] 当前 span
+          # @param trace [Datadog::Tracing::TraceOperation] 当前 trace
+          # @param request [Net::HTTPRequest] HTTP 请求对象
+          # @param service_name [String] 服务名称
+          def self.inject!(span, trace, request, service_name = nil)
+            return unless span && trace
+
+            service_name ||= Datadog.configuration.service
+            return unless service_name
+
+            # 获取目标 URL
+            target_url = extract_target_url(request)
+
+            # 构建 CLOUDWISE header 值
+            cloudwise_value = build_cloudwise_value(
+              span: span,
+              trace: trace,
+              service_name: service_name,
+              target_url: target_url
+            )
+
+            # 添加到请求头
+            request[HEADER_NAME] = cloudwise_value if cloudwise_value
+
+            Datadog.logger.debug do
+              "Injected CLOUDWISE header: #{cloudwise_value}"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error injecting CLOUDWISE header: #{e.message}\n#{e.backtrace.join("\n")}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 构建 CLOUDWISE 值
+          # 格式：[type_from]:[sample]:[host_id]:[app_id]:[instance_id]:[trace_id]:[assumed_app_id]:[span_id]:[segment_id]:[app_name]
+          def self.build_cloudwise_value(span:, trace:, service_name:, target_url:)
+            type_from = TYPE_FROM
+            sample = 0
+            host_id = get_host_id
+            app_id = generate_app_id(service_name)
+            instance_id = get_instance_id
+            # 使用低 64 位 trace_id，与上报保持一致
+            trace_id = Tracing::Utils::TraceId.to_low_order(trace.id).to_s
+            assumed_app_id = generate_assumed_app_id(target_url)
+            span_id = span.id.to_s
+            segment_id = get_segment_id(span)
+            app_name = service_name
+
+            "#{type_from}:#{sample}:#{host_id}:#{app_id}:#{instance_id}:#{trace_id}:#{assumed_app_id}:#{span_id}:#{segment_id}:#{app_name}"
+          end
+
+          # 计算采样率
+          # 0: 全采样, 1: 不采样
+          def self.calculate_sample_rate
+            sample_rate = Datadog.configuration.tracing.sampling.default_rate
+            # 如果采样率 >= 1.0，表示全采样，返回 0
+            # 否则返回 1 表示不采样
+            (sample_rate && sample_rate >= 1.0) ? 0 : 1
+          rescue
+            1 # 默认不采样
+          end
+
+          # 获取主机 ID（基于 account_id + host_ip 的 MD5）
+          # account_id: 账户ID，通过接口获取，暂定默认 110
+          # host_ip: 本机 IP 地址
+          # 返回格式: MD5(account_id + host_ip) 的十进制字符串
+          def self.get_host_id
+            @host_id ||= begin
+              account_id = get_account_id
+              host_ip = get_host_ip
+
+              # 生成 host_id: MD5(account_id + host_ip)
+              combined = "#{account_id}#{host_ip}"
+              md5_hex = Digest::MD5.hexdigest(combined)
+              # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+              # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+              md5_hex[0..14].to_i(16).to_s
+            rescue => e
+              Datadog.logger.debug { "Error generating host_id: #{e.message}" } if defined?(Datadog.logger)
+              # 降级方案：使用 hostname 的 MD5
+              md5_hex = Digest::MD5.hexdigest(Socket.gethostname)
+              md5_hex[0..14].to_i(16).to_s
+            end
+          end
+
+          # 获取账户 ID
+          # TODO: 实际应该通过接口获取，当前暂定默认值 110
+          def self.get_account_id
+            @account_id ||= ENV['CLOUDWISE_ACCOUNT_ID'] || '110'
+          end
+
+          # 获取本机 IP 地址
+          def self.get_host_ip
+            @host_ip ||= begin
+              # 尝试获取本机 IP（优先非回环的 IPv4 地址）
+              ip = Socket.ip_address_list.find { |addr| addr.ipv4? && !addr.ipv4_loopback? }
+              ip ? ip.ip_address : '127.0.0.1'
+            rescue => e
+              Datadog.logger.debug { "Error getting host IP: #{e.message}" } if defined?(Datadog.logger)
+              '127.0.0.1'
+            end
+          end
+
+          # 生成 app_id（基于服务名称的 MD5）
+          def self.generate_app_id(service_name)
+            @app_id_cache ||= {}
+            @app_id_cache[service_name] ||= begin
+              # 计算 MD5 并转换为数字
+              md5_hex = Digest::MD5.hexdigest(service_name)
+              # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+              # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+              md5_hex[0..14].to_i(16).to_s
+            end
+          end
+
+          # 获取实例 ID（基于 host_ip + port 的 MD5）
+          # host_ip: 本机 IP 地址
+          # port: 应用端口
+          # 返回格式: MD5(host_ip + port) 的十进制字符串
+          def self.get_instance_id
+            @instance_id ||= begin
+              host_ip = get_host_ip
+              port = get_process_port
+
+              # 生成 instance_id: MD5(host_ip + port)
+              combined = "#{host_ip}#{port}"
+              md5_hex = Digest::MD5.hexdigest(combined)
+              # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+              # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+              md5_hex[0..14].to_i(16).to_s
+            rescue => e
+              Datadog.logger.debug { "Error generating instance_id: #{e.message}" } if defined?(Datadog.logger)
+              # 降级方案：使用进程 PID
+              Process.pid.to_s
+            end
+          end
+
+          # 获取进程端口（尝试从环境变量获取）
+          def self.get_process_port
+            # 尝试从常见的环境变量中获取端口
+            port = ENV['PORT'] || ENV['APP_PORT']
+            return port.to_i if port && !port.empty?
+
+            # 默认返回 -1 表示未知端口
+            -1
+          end
+
+          # 生成 assumed_app_id（基于目标 URL 的域名/IP:端口）
+          def self.generate_assumed_app_id(url)
+            return '-1' unless url
+
+            uri = URI.parse(url)
+            target = "#{uri.host}:#{uri.port}"
+
+            # 使用与 app_id 相同的生成逻辑
+            md5_hex = Digest::MD5.hexdigest(target)
+            # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+            # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+            md5_hex[0..14].to_i(16).to_s
+          rescue => e
+            Datadog.logger.debug { "Error generating assumed_app_id: #{e.message}" } if defined?(Datadog.logger)
+            '-1'
+          end
+
+          # 获取 segment_id（请求唯一标识）
+          # 如果 span 有自定义的 segment_id，使用它；否则返回 -1
+          def self.get_segment_id(span)
+            span.get_tag('segment_id') || '-1'
+          end
+
+          # 从请求对象中提取目标 URL
+          def self.extract_target_url(request)
+            return nil unless request
+
+            # 尝试从不同类型的请求对象中提取 URL
+            if request.respond_to?(:uri) && request.uri
+              request.uri.to_s
+            elsif request.respond_to?(:path)
+              # Net::HTTP::Request
+              host = request['Host'] || 'unknown'
+              scheme = request.instance_variable_get(:@is_secure) ? 'https' : 'http'
+              "#{scheme}://#{host}#{request.path}"
+            else
+              nil
+            end
+          rescue => e
+            Datadog.logger.debug { "Error extracting target URL: #{e.message}" } if defined?(Datadog.logger)
+            nil
+          end
+
+          # 为 span 添加 app_id 标签
+          def self.tag_span_with_app_id(span, service_name)
+            return unless span && service_name
+
+            app_id = generate_app_id(service_name)
+            span.set_tag('app_id', app_id)
+
+            Datadog.logger.debug do
+              "Set app_id tag on span: #{app_id} (service: #{service_name})"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error setting app_id tag: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 从入站请求中提取 CLOUDWISE 头并设置到 span
+          # @param span [Datadog::Tracing::SpanOperation] 当前 span
+          # @param cloudwise_header [String] CLOUDWISE 请求头的值
+          def self.extract_and_tag_from_header!(span, cloudwise_header)
+            return unless span && cloudwise_header
+
+            # 解析 CLOUDWISE 头
+            fields = parse_cloudwise_header(cloudwise_header)
+            return unless fields
+
+            # 为 span 添加标签（除了 type_from，其他字段都加 _from 后缀）
+            span.set_tag('type_from', fields[:type_from]) if fields[:type_from]
+            span.set_tag('sample_from', fields[:sample]) if fields[:sample]
+            span.set_tag('host_id_from', fields[:host_id]) if fields[:host_id]
+            span.set_tag('app_id_from', fields[:app_id]) if fields[:app_id]
+            span.set_tag('instance_id_from', fields[:instance_id]) if fields[:instance_id]
+            span.set_tag('trace_id_from', fields[:trace_id]) if fields[:trace_id]
+            span.set_tag('assumed_app_id_from', fields[:assumed_app_id]) if fields[:assumed_app_id]
+            span.set_tag('span_id_from', fields[:span_id]) if fields[:span_id]
+            span.set_tag('segment_id_from', fields[:segment_id]) if fields[:segment_id]
+            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]}"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error extracting CLOUDWISE header: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 解析 CLOUDWISE 请求头
+          # 格式：[type_from]:[sample]:[host_id]:[app_id]:[instance_id]:[trace_id]:[assumed_app_id]:[span_id]:[segment_id]:[app_name]
+          # @param header_value [String] CLOUDWISE 请求头的值
+          # @return [Hash, nil] 解析后的字段哈希，如果解析失败返回 nil
+          def self.parse_cloudwise_header(header_value)
+            return nil unless header_value.is_a?(String)
+
+            # 去除首尾空格
+            header_value = header_value.strip
+            return nil if header_value.empty?
+
+            # 以冒号分隔字段
+            parts = header_value.split(':')
+
+            # 至少需要 10 个字段
+            if parts.length < 10
+              Datadog.logger.debug do
+                "CLOUDWISE header has insufficient fields: expected 10, got #{parts.length}"
+              end if defined?(Datadog.logger)
+              return nil
+            end
+
+            # 构建字段哈希
+            {
+              type_from: parts[FIELD_TYPE_FROM]&.strip,
+              sample: parts[FIELD_SAMPLE]&.strip,
+              host_id: parts[FIELD_HOST_ID]&.strip,
+              app_id: parts[FIELD_APP_ID]&.strip,
+              instance_id: parts[FIELD_INSTANCE_ID]&.strip,
+              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,
+              app_name: parts[FIELD_APP_NAME]&.strip
+            }
+          rescue => e
+            Datadog.logger.error do
+              "Error parsing CLOUDWISE header: #{e.message}"
+            end if defined?(Datadog.logger)
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Initialization hooks for Contrib integrations
+      module Component
+        class << self
+          # Register a callback to be invoked when components are reconfigured.
+          # @param name [String] the name of the integration
+          # @param callback [Proc] the callback to invoke
+          # @yieldparam config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
+          def register(name, &callback)
+            @registry[name] = callback
+          end
+
+          # Invoke all registered callbacks with the given configuration.
+          # @param config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
+          def configure(config)
+            @registry.each do |name, callback|
+              callback.call(config)
+            rescue => e
+              Datadog.logger.warn("Error configuring integration #{name}: #{e}")
+            end
+          end
+
+          private
+
+          # Unregister a callback. This is only used for testing.
+          # @param name [String] the name of the integration
+          def unregister(name)
+            @registry.delete(name)
+          end
+        end
+
+        # @return [Hash<String, Proc>] the registry of callbacks
+        @registry = {}
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/concurrent_ruby/async_patch.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'context_composite_executor_service'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # This patches the Async - to wrap executor service using ContextCompositeExecutorService
+        module AsyncPatch
+          def initialize(delegate)
+            super
+
+            @executor = ContextCompositeExecutorService.new(@executor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        module Configuration
+          # Custom settings for the ConcurrentRuby integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/concurrent_ruby/context_composite_executor_service.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'concurrent/executor/executor_service'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # Wraps existing executor to carry over trace context
+        class ContextCompositeExecutorService
+          include Concurrent::ExecutorService
+
+          attr_accessor :composited_executor
+
+          def initialize(composited_executor)
+            @composited_executor = composited_executor
+          end
+
+          # post method runs the task within composited executor - in a different thread. The original arguments are
+          # captured to be propagated to the composited executor post method
+          def post(*args, &task)
+            digest = Tracing.active_trace&.to_digest
+            executor = @composited_executor.is_a?(Symbol) ? Concurrent.executor(@composited_executor) : @composited_executor
+
+            # Pass the original arguments to the composited executor, which
+            # pushes them (possibly transformed) as block args
+            executor.post(*args) do |*block_args|
+              Tracing.continue_trace!(digest)
+
+              # Pass the executor-provided block args as they should have been
+              # originally passed without composition, see ChainPromise#on_resolvable
+              yield(*block_args)
+            end
+          end
+
+          # Respect the {Concurrent::ExecutorService} interface
+          def can_overflow?
+            @composited_executor.can_overflow?
+          end
+
+          # Respect the {Concurrent::ExecutorService} interface
+          def serialized?
+            @composited_executor.serialized?
+          end
+
+          def datadog_configuration
+            Datadog.configuration.tracing[:concurrent_ruby]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # ConcurrentRuby integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          APP = 'concurrent-ruby'
+          ENV_ENABLED = 'DD_TRACE_CONCURRENT_RUBY_ENABLED'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/concurrent_ruby/future_patch.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'context_composite_executor_service'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+        module FuturePatch
+          def ns_initialize(value, opts)
+            super
+
+            @executor = ContextCompositeExecutorService.new(@executor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'patcher'
+require_relative 'configuration/settings'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # Describes the ConcurrentRuby integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.9')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :concurrent_ruby
+          def self.gem_name
+            'concurrent-ruby'
+          end
+
+          def self.version
+            Gem.loaded_specs['concurrent-ruby']&.version
+          end
+
+          def self.loaded?
+            # Concurrent::Future is deprecated in favour of Concurrent::Promises::Future
+            !defined?(::Concurrent::Promises::Future).nil? || !defined?(::Concurrent::Future).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/concurrent_ruby/patcher.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # Patcher enables patching of 'Future' and 'Async' classes.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'future_patch'
+            patch_future
+            require_relative 'promises_future_patch'
+            patch_promises_future
+            require_relative 'async_patch'
+            async_patch
+          end
+
+          # Propagate tracing context in Concurrent::Async
+          def async_patch
+            if defined?(::Concurrent::Async)
+              # NOTE: AsyncDelegator is a private constant
+              ::Concurrent::Async.const_get(:AsyncDelegator).prepend(AsyncPatch)
+            end
+          end
+
+          # Propagate tracing context in Concurrent::Future
+          def patch_future
+            ::Concurrent::Future.prepend(FuturePatch) if defined?(::Concurrent::Future)
+          end
+
+          # Propagate tracing context in Concurrent::Promises::Future
+          def patch_promises_future
+            ::Concurrent::Promises.singleton_class.prepend(PromisesFuturePatch) if defined?(::Concurrent::Promises::Future)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/concurrent_ruby/promises_future_patch.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'context_composite_executor_service'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+        module PromisesFuturePatch
+          def future_on(default_executor, *args, &task)
+            unless default_executor.is_a?(ContextCompositeExecutorService)
+              default_executor = ContextCompositeExecutorService.new(default_executor)
+            end
+
+            super
+          end
+        end
+      end
+    end
+  end
+end