cw-datadog 2.23.0.4 → 2.23.0.5

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    module Configuration
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.normalize_temporality_preference(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using delta instead.")
+              'delta'
+            else
+              value
+            end
+          end
+        end
+
+        def self.normalize_protocol(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'http/protobuf'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using http/protobuf instead.")
+            end
+            'http/protobuf'
+          end
+        end
+
+        def self.headers_parser(env_var_name)
+          lambda do |value|
+            return {} if value.nil? || value.empty?
+
+            headers = {}
+            header_items = value.split(',')
+            header_items.each do |key_value|
+              key, header_value = key_value.split('=', 2)
+              # If header is malformed, return an empty hash
+              if key.nil? || header_value.nil?
+                Datadog.logger.warn("#{env_var_name} has malformed header: #{key_value.inspect}")
+                return {}
+              end
+
+              key.strip!
+              header_value.strip!
+              if key.empty? || header_value.empty?
+                Datadog.logger.warn("#{env_var_name} has empty key or value in: #{key_value.inspect}")
+                return {}
+              end
+
+              headers[key] = header_value
+            end
+            headers
+          end
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :opentelemetry do
+              settings :exporter do
+                option :protocol do |o|
+                  o.type :string
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_PROTOCOL'))
+                  o.env 'OTEL_EXPORTER_OTLP_PROTOCOL'
+                  o.default 'http/protobuf'
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_EXPORTER_OTLP_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :headers do |o|
+                  o.type :hash
+                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.default { {} }
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_ENDPOINT'
+                  o.default nil
+                end
+              end
+
+              settings :metrics do
+                # Metrics-specific options default to nil to detect unset state.
+                # If a metrics-specific env var (e.g., OTEL_EXPORTER_OTLP_METRICS_TIMEOUT) is not set,
+                # we fall back to the general OTLP env var (e.g., OTEL_EXPORTER_OTLP_TIMEOUT) per OpenTelemetry spec.
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_METRICS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_METRICS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :export_interval_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_INTERVAL'
+                  o.default 10_000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_TIMEOUT'
+                  o.default 7_500
+                end
+
+                option :temporality_preference do |o|
+                  o.type :string
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'
+                  o.default 'delta'
+                  o.setter(&Settings.normalize_temporality_preference('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
+                  o.default nil
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.default nil
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/metrics.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    class Metrics
+      EXPORTER_NONE = 'none'
+
+      def self.initialize!(components)
+        new(components).configure_metrics_sdk
+        true
+      rescue => exc
+        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_metrics_sdk
+        provider = ::OpenTelemetry.meter_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+        # The OpenTelemetry SDK defaults to cumulative temporality, but Datadog prefers delta temporality.
+        # Here is an example of how this config is applied: https://github.com/open-telemetry/opentelemetry-ruby/blob/1933d4c18e5f5e45c53fa9e902e58aa91e85cc38/metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb#L14
+        if DATADOG_ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].nil?
+          ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' # rubocop:disable CustomCops/EnvUsageCop
+        end
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+        configure_metric_reader(provider)
+        ::OpenTelemetry.meter_provider = provider
+      end
+
+      private
+
+      def create_resource
+        resource_attributes = {}
+        resource_attributes['host.name'] = Datadog::Core::Environment::Socket.hostname if @settings.tracing.report_hostname
+
+        @settings.tags&.each do |key, value|
+          otel_key = case key
+          when 'service' then 'service.name'
+          when 'env' then 'deployment.environment'
+          when 'version' then 'service.version'
+          else key
+          end
+          resource_attributes[otel_key] = value
+        end
+
+        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        resource_attributes['deployment.environment'] = @settings.env if @settings.env
+        resource_attributes['service.version'] = @settings.version if @settings.version
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      def configure_metric_reader(provider)
+        exporter_name = @settings.opentelemetry.metrics.exporter
+        return if exporter_name == EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+
+      def resolve_metrics_endpoint
+        metrics_config = @settings.opentelemetry.metrics
+        exporter_config = @settings.opentelemetry.exporter
+
+        return metrics_config.endpoint if metrics_config.endpoint
+        return exporter_config.endpoint if exporter_config.endpoint
+        "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
+      end
+
+      def configure_otlp_exporter(provider)
+        require 'opentelemetry/exporter/otlp_metrics'
+        require_relative 'sdk/metrics_exporter'
+
+        metrics_config = @settings.opentelemetry.metrics
+        exporter_config = @settings.opentelemetry.exporter
+        timeout = metrics_config.timeout_millis || exporter_config.timeout_millis
+        headers = metrics_config.headers || exporter_config.headers || {}
+
+        protocol = metrics_config.protocol || exporter_config.protocol
+        exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
+          endpoint: resolve_metrics_endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers,
+          protocol: protocol
+        )
+
+        reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+          exporter: exporter,
+          export_interval_millis: metrics_config.export_interval_millis,
+          export_timeout_millis: metrics_config.export_timeout_millis
+        )
+        provider.add_metric_reader(reader)
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -30,7 +30,31 @@ module Datadog
           [SpanProcessor.new]
         end
 
-        ::OpenTelemetry::SDK::Configurator.prepend(self)
+        def metrics_configuration_hook
+          components = Datadog.send(:components)
+          return super unless components.settings.opentelemetry.metrics.enabled
+
+          begin
+            require 'opentelemetry-metrics-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            return super
+          end
+
+          success = Datadog::OpenTelemetry::Metrics.initialize!(components)
+          super unless success
+        end
+
+        # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
+        begin
+          require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
+        end
+        ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_metrics'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class MetricsExporter < ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
+
+        def initialize(endpoint:, timeout:, headers:, protocol:)
+          super(endpoint: endpoint, timeout: timeout, headers: headers)
+          @telemetry_tags = {'protocol' => protocol, 'encoding' => 'protobuf'}
+        end
+
+        def export(metrics, timeout: nil)
+          telemetry&.inc('tracers', METRIC_EXPORT_ATTEMPTS, 1, tags: @telemetry_tags)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          telemetry&.inc('tracers', metric_name, 1, tags: @telemetry_tags)
+          result
+        rescue => e
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
+          telemetry&.inc('tracers', METRIC_EXPORT_FAILURES, 1, tags: @telemetry_tags)
+          raise
+        end
+
+        private
+
+        def telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -22,6 +22,8 @@ require_relative 'opentelemetry/api/baggage'
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
+require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+
 module Datadog
   # Datadog OpenTelemetry integration.
   module OpenTelemetry
@@ -47,6 +49,7 @@ end
 # Currently, this closely translates to Datadog's partial flushing.
 #
 # @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+
 Datadog.configure do |c|
   c.tracing.partial_flush.enabled = true
 end

data/lib/datadog/tracing/configuration/ext.rb

@@ -15,6 +15,7 @@ module Datadog
         ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
         ENV_RESOURCE_RENAMING_ENABLED = 'DD_TRACE_RESOURCE_RENAMING_ENABLED'
         ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = 'DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT'
+        ENV_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
 
         # @public_api
         module SpanAttributeSchema

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

@@ -163,6 +163,15 @@ module Datadog
             end
           end
 
+          # 获取当前应用的 app_id
+          # 用于 Consumer 端设置 app_id_to 标签，表示当前消费消息的应用
+          # @return [String, nil] 当前应用的 app_id
+          def self.get_current_app_id
+            service_name = Datadog.configuration.service
+            return nil unless service_name
+            generate_app_id(service_name)
+          end
+
           # 获取实例 ID（基于 host_ip + port 的 MD5）
           # host_ip: 本机 IP 地址
           # port: 应用端口
@@ -265,16 +274,22 @@ module Datadog
             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]
+            tags = {}
+            tags['type_from'] = fields[:type_from] if fields[:type_from]
+            tags['sample_from'] = fields[:sample] if fields[:sample]
+            tags['host_id_from'] = fields[:host_id] if fields[:host_id]
+            tags['app_id_from'] = fields[:app_id] if fields[:app_id]
+            tags['instance_id_from'] = fields[:instance_id] if fields[:instance_id]
+            tags['trace_id_from'] = fields[:trace_id] if fields[:trace_id]
+            tags['assumed_app_id_from'] = fields[:assumed_app_id] if fields[:assumed_app_id]
+            tags['span_id_from'] = fields[:span_id] if fields[:span_id]
+            tags['segment_id_from'] = fields[:segment_id] if fields[:segment_id]
+            tags['app_name_from'] = fields[:app_name] if fields[:app_name]
+            
+            current_app_id = get_current_app_id
+            tags['app_id'] = current_app_id if current_app_id
+            
+            span.set_tags(tags) unless tags.empty?
 
             Datadog.logger.debug do
               "Extracted CLOUDWISE header : cloudwise_header=#{cloudwise_header}"
@@ -339,8 +354,17 @@ module Datadog
           end
 
           # 获取当前服务的 sys 值
-          # @return [String] sys 值，默认为 'default'
+          # 优先级: Datadog.configuration.cloudwise.sys > CW_SYS 环境变量 > 默认值 'default'
           def self.get_sys
+            # 优先从配置读取
+            if defined?(Datadog.configuration) &&
+               Datadog.configuration.respond_to?(:cloudwise) &&
+               Datadog.configuration.cloudwise.respond_to?(:sys)
+              sys = Datadog.configuration.cloudwise.sys
+              return sys if sys && !sys.empty? && sys != 'default'
+            end
+
+            # 其次从环境变量读取
             ENV['CW_SYS'] || 'default'
           end
 
@@ -435,35 +459,137 @@ module Datadog
             other_header = request_headers[HEADER_OTHER_NAME] ||
                           request_headers['HTTP_' + HEADER_OTHER_NAME.upcase.gsub('-', '_')]
 
+            # ✅ 优化：使用 set_tags 批量设置，减少锁竞争
+            tags = {}
+            
             if other_header
               # 解析 CLOUDWISE-OTHER：service_type_from:parent_sys
               parts = other_header.split(':')
 
-              service_type_from = normalize_field_value(parts[FIELD_OTHER_SERVICE_TYPE_FROM])
-              parent_sys = normalize_field_value(parts[FIELD_OTHER_PARENT_SYS])
+              service_type_from = parts[FIELD_OTHER_SERVICE_TYPE_FROM].to_s.strip
+              parent_sys = parts[FIELD_OTHER_PARENT_SYS].to_s.strip
 
               # 只添加上游相关的字段到 span tags
               # sys 和 service_instance_id 将在 tag_cloudwise_metadata! 中设置
-              span.set_tag('service_type_from', service_type_from)
-              span.set_tag('parent_sys', parent_sys)
+              tags['service_type_from'] = service_type_from
+              tags['parent_sys'] = parent_sys
 
               Datadog.logger.debug do
                 "Extracted CLOUDWISE-OTHER from request: service_type_from=#{service_type_from}, parent_sys=#{parent_sys}"
               end if defined?(Datadog.logger)
             else
               # 如果没有上游请求头，设置为空字符串
-              span.set_tag('service_type_from', '')
-              span.set_tag('parent_sys', '')
+              tags['service_type_from'] = ''
+              tags['parent_sys'] = ''
 
               Datadog.logger.debug do
                 "No CLOUDWISE-OTHER header in request, set service_type_from and parent_sys to empty"
               end if defined?(Datadog.logger)
             end
+            
+            span.set_tags(tags) unless tags.empty?
           rescue => e
             Datadog.logger.error do
               "Error extracting CLOUDWISE-OTHER: #{e.message}"
             end if defined?(Datadog.logger)
           end
+
+          # ===== Kafka 相关方法 =====
+
+          # 为 Kafka 消息注入 CLOUDWISE header
+          # @param message_headers [Hash] Kafka 消息的 headers
+          # @param topic [String] Kafka topic 名称
+          # @param service_name [String] 服务名称
+          def self.inject_kafka_headers!(message_headers, topic, service_name = nil)
+            return unless message_headers
+
+            service_name ||= Datadog.configuration.service
+            return unless service_name
+
+            # 获取当前活跃的 span 和 trace
+            span = Datadog::Tracing.active_span
+            trace = Datadog::Tracing.active_trace
+            return unless span && trace
+
+            # 构建 CLOUDWISE header 值
+            cloudwise_value = build_cloudwise_value_for_kafka(
+              span: span,
+              trace: trace,
+              service_name: service_name,
+              topic: topic
+            )
+
+            # 添加到消息 headers
+            message_headers[HEADER_NAME] = cloudwise_value if cloudwise_value
+
+            Datadog.logger.debug do
+              "Injected Kafka CLOUDWISE header: #{cloudwise_value}"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error injecting Kafka CLOUDWISE header: #{e.message}\n#{e.backtrace.join("\n")}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 构建 Kafka 消息的 CLOUDWISE 值
+          # 格式：[type_from]:[sample]:[host_id]:[app_id]:[instance_id]:[trace_id]:[assumed_app_id]:[span_id]:[segment_id]:[app_name]
+          # @param span [Datadog::Tracing::SpanOperation] 当前 span
+          # @param trace [Datadog::Tracing::TraceOperation] 当前 trace
+          # @param service_name [String] 服务名称
+          # @param topic [String] Kafka topic 名称
+          # @return [String] CLOUDWISE header 值
+          def self.build_cloudwise_value_for_kafka(span:, trace:, service_name:, topic:)
+            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
+            # 对于 Kafka，使用 topic 生成 assumed_app_id
+            assumed_app_id = generate_assumed_app_id_for_kafka(topic)
+            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
+
+          # 为 Kafka topic 生成 assumed_app_id
+          # @param topic [String] Kafka topic 名称
+          # @return [String] assumed_app_id
+          def self.generate_assumed_app_id_for_kafka(topic)
+            return '-1' unless topic
+
+            # 使用 topic 名称生成 assumed_app_id
+            md5_hex = Digest::MD5.hexdigest("kafka:#{topic}")
+            # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+            md5_hex[0..14].to_i(16).to_s
+          rescue => e
+            Datadog.logger.debug { "Error generating assumed_app_id for Kafka: #{e.message}" } if defined?(Datadog.logger)
+            '-1'
+          end
+
+          # 从 Kafka 消息 headers 中提取 CLOUDWISE header 并设置到 span
+          # @param span [Datadog::Tracing::SpanOperation] 当前 span
+          # @param headers [Hash] Kafka 消息的 headers
+          def self.extract_kafka_cloudwise_headers!(span, headers)
+            return unless span && headers
+
+            # 提取 CLOUDWISE header
+            cloudwise_header = headers[HEADER_NAME]
+            if cloudwise_header
+              extract_and_tag_from_header!(span, cloudwise_header)
+            end
+
+            Datadog.logger.debug do
+              "Extracted Kafka CLOUDWISE headers from message"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error extracting Kafka CLOUDWISE headers: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
         end
       end
     end