cw-datadog 2.23.0.2 → 2.23.0.3

data/lib/datadog/open_feature/ext.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Ext
+      ERROR = 'ERROR'
+      INITIALIZING = 'INITIALIZING'
+      UNKNOWN_TYPE = 'UNKNOWN_TYPE'
+      PROVIDER_FATAL = 'PROVIDER_FATAL'
+      PROVIDER_NOT_READY = 'PROVIDER_NOT_READY'
+    end
+  end
+end

data/lib/datadog/open_feature/noop_evaluator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'resolution_details'
+
+module Datadog
+  module OpenFeature
+    # This class is a noop interface of evaluation logic
+    class NoopEvaluator
+      def initialize(_configuration)
+        # no-op
+      end
+
+      def get_assignment(_flag_key, default_value, _context, _expected_type)
+        ResolutionDetails.new(
+          value: default_value,
+          log?: false,
+          error?: true,
+          error_code: Ext::PROVIDER_NOT_READY,
+          error_message: 'Waiting for universal flag configuration',
+          reason: Ext::INITIALIZING
+        )
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/provider.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require 'open_feature/sdk'
+
+module Datadog
+  module OpenFeature
+    # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
+    #
+    # Implementation follows the OpenFeature contract of Provider SDK.
+    # For details see:
+    #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/README.md#develop-a-provider
+    #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/lib/open_feature/sdk/provider/no_op_provider.rb
+    #
+    # In the example below you can see how to configure the OpenFeature SDK
+    # https://github.com/open-feature/ruby-sdk to use the Datadog feature flags provider.
+    #
+    # Example:
+    #
+    #   Make sure to enable Remote Configuration and OpenFeature in the Datadog configuration.
+    #
+    #   ```ruby
+    #   # FILE: initializers/datadog.rb
+    #   Datadog.configure do |config|
+    #     config.remote.enabled = true
+    #     config.open_feature.enabled = true
+    #   end
+    #   ```
+    #
+    #   And configure the OpenFeature SDK to use the Datadog feature flagging provider.
+    #
+    #   ```ruby
+    #   # FILE: initializers/open_feature.rb
+    #   require 'open_feature/sdk'
+    #   require 'datadog/open_feature/provider'
+    #
+    #   OpenFeature::SDK.configure do |config|
+    #     config.set_provider(Datadog::OpenFeature::Provider.new)
+    #   end
+    #   ```
+    #
+    #   Now you can create OpenFeature SDK client and use it to fetch feature flag values.
+    #
+    #   ```ruby
+    #   client = OpenFeature::SDK.build_client
+    #   context = OpenFeature::SDK::EvaluationContext.new('email' => 'john.doe@gmail.com')
+    #
+    #   client.fetch_string_value(
+    #     flag_key: 'banner', default_value: 'Greetings!', evaluation_context: context
+    #   )
+    #   # => 'Welcome back!'
+    #   ```
+    class Provider
+      NAME = 'Datadog Feature Flagging Provider'
+
+      attr_reader :metadata
+
+      def initialize
+        @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: NAME).freeze
+      end
+
+      def init
+        # no-op
+      end
+
+      def shutdown
+        # no-op
+      end
+
+      def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'boolean', evaluation_context: evaluation_context)
+      end
+
+      def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'string', evaluation_context: evaluation_context)
+      end
+
+      def fetch_number_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'number', evaluation_context: evaluation_context)
+      end
+
+      def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'integer', evaluation_context: evaluation_context)
+      end
+
+      def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'float', evaluation_context: evaluation_context)
+      end
+
+      def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: 'object', evaluation_context: evaluation_context)
+      end
+
+      private
+
+      def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
+        engine = OpenFeature.engine
+        return component_not_configured_default(default_value) if engine.nil?
+
+        result = engine.fetch_value(
+          flag_key: flag_key,
+          default_value: default_value,
+          expected_type: expected_type,
+          evaluation_context: evaluation_context
+        )
+
+        if result.error?
+          return ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+            value: result.value,
+            error_code: result.error_code,
+            error_message: result.error_message,
+            reason: result.reason
+          )
+        end
+
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: result.value,
+          variant: result.variant,
+          reason: result.reason,
+          flag_metadata: result.flag_metadata
+        )
+      end
+
+      def component_not_configured_default(value)
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: value,
+          error_code: Ext::PROVIDER_FATAL,
+          error_message: "Datadog's OpenFeature component must be configured",
+          reason: Ext::ERROR
+        )
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/remote.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../core/remote/dispatcher'
+
+module Datadog
+  module OpenFeature
+    # This module contains the remote configuration functionality for OpenFeature
+    module Remote
+      ReadError = Class.new(StandardError)
+
+      class << self
+        FFE_FLAG_CONFIGURATION_RULES = 1 << 46
+        FFE_PRODUCTS = ['FFE_FLAGS'].freeze
+        FFE_CAPABILITIES = [FFE_FLAG_CONFIGURATION_RULES].freeze
+
+        def capabilities
+          FFE_CAPABILITIES
+        end
+
+        def products
+          FFE_PRODUCTS
+        end
+
+        def receivers(telemetry)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
+          receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
+            engine = OpenFeature.engine
+            break unless engine
+
+            changes.each do |change|
+              content = repository[change.path]
+
+              unless content || change.type == :delete
+                next telemetry.error("OpenFeature: Remote Configuration change is not present on #{change.type}")
+              end
+
+              # NOTE: In the current RC implementation we immediately apply the configuration,
+              #       but that might change if we need to apply patches instead.
+              case change.type
+              when :insert, :update
+                begin
+                  # @type var content: Core::Remote::Configuration::Content
+                  engine.reconfigure!(read_content(content))
+                  content.applied
+                rescue ReadError => e
+                  content.errored("Error reading Remote Configuration content: #{e.message}")
+                rescue EvaluationEngine::ReconfigurationError => e
+                  content.errored("Error applying OpenFeature configuration: #{e.message}")
+                end
+              when :delete
+                # NOTE: For now, we treat deletion as clearing the configuration
+                #       In a multi-config scenario, we might track configs per path
+                engine.reconfigure!(nil)
+              end
+            end
+          end
+
+          [receiver]
+        end
+
+        private
+
+        def read_content(content)
+          data = content.data.read
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/resolution_details.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module OpenFeature
+    # This class is based on the `OpenFeature::SDK::Provider::ResolutionDetails` class
+    #
+    # See: https://github.com/open-feature/ruby-sdk/blob/v0.4.1/lib/open_feature/sdk/provider/resolution_details.rb
+    class ResolutionDetails < Struct.new(
+      :value,
+      :reason,
+      :variant,
+      :error_code,
+      :error_message,
+      :flag_metadata,
+      :allocation_key,
+      :extra_logging,
+      :log?,
+      :error?,
+      keyword_init: true
+    )
+      def self.build_error(value:, error_code:, error_message:, reason: Ext::ERROR)
+        new(
+          value: value,
+          error_code: error_code,
+          error_message: error_message,
+          reason: reason,
+          error?: true,
+          log?: false
+        ).freeze
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/transport.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../core/transport/http'
+require_relative '../core/transport/http/env'
+require_relative '../core/transport/parcel'
+require_relative '../core/transport/request'
+
+module Datadog
+  module OpenFeature
+    module Transport
+      class EncodedParcel
+        include Core::Transport::Parcel
+
+        def encode_with(encoder)
+          encoder.encode(data)
+        end
+      end
+
+      class HTTP
+        class Spec < Core::Transport::HTTP::API::Spec
+          def initialize
+            @endpoint = Core::Transport::HTTP::API::Endpoint.new(
+              :post, '/evp_proxy/v2/api/v2/exposures'
+            )
+
+            super
+          end
+
+          def call(env, &block)
+            @endpoint.call(env) do |request_env|
+              request_env.headers['Content-Type'] = Core::Encoding::JSONEncoder.content_type
+              request_env.headers['X-Datadog-EVP-Subdomain'] = 'event-platform-intake'
+              request_env.body = env.request.parcel.encode_with(Core::Encoding::JSONEncoder)
+
+              block.call(request_env)
+            end
+          end
+        end
+
+        class Instance < Core::Transport::HTTP::API::Instance
+          def send_exposures(env)
+            @spec.call(env) { |request_env| call(request_env) }
+          end
+        end
+
+        def self.build(agent_settings:, logger:)
+          Core::Transport::HTTP.build(
+            api_instance_class: HTTP::Instance,
+            agent_settings: agent_settings,
+            logger: logger
+          ) { |t| t.api('exposures', HTTP::Spec.new) }.to_transport(self)
+        end
+
+        def initialize(apis, default_api, logger:)
+          @api = apis[default_api]
+          @logger = logger
+        end
+
+        def send_exposures(payload)
+          request = Core::Transport::Request.new(EncodedParcel.new(payload))
+          @api.send_exposures(Core::Transport::HTTP::Env.new(request))
+        rescue => e
+          message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
+                    "Location: #{Array(e.backtrace).first}"
+          @logger.debug(message)
+
+          Core::Transport::InternalErrorResponse.new(e)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'core/configuration'
+require_relative 'open_feature/configuration'
+
+module Datadog
+  # A namespace for the OpenFeature component.
+  module OpenFeature
+    Core::Configuration::Settings.extend(Configuration::Settings)
+
+    def self.enabled?
+      Datadog.configuration.open_feature.enabled
+    end
+
+    def self.engine
+      Datadog.send(:components).open_feature&.engine
+    end
+  end
+end

data/lib/datadog/profiling/component.rb

@@ -220,6 +220,12 @@ module Datadog
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
           return false
+        elsif RUBY_VERSION.start_with?("4.")
+          logger.warn(
+            "Heap profiling is not supported in current Ruby version (#{RUBY_VERSION}) due to https://bugs.ruby-lang.org/issues/21710. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
         unless allocation_profiling_enabled

data/lib/datadog/profiling/profiler.rb

@@ -17,6 +17,10 @@ module Datadog
         @scheduler = scheduler
       end
 
+      def enabled?
+        scheduler.running?
+      end
+
       def start
         after_fork! do
           worker.reset_after_fork

data/lib/datadog/profiling.rb

@@ -62,8 +62,7 @@ module Datadog
 
     def self.enabled?
       profiler = Datadog.send(:components).profiler
-      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!profiler&.send(:scheduler)&.running?
+      !!profiler&.enabled?
     end
 
     def self.wait_until_running(timeout_seconds: 5)

data/lib/datadog/single_step_instrument.rb

@@ -15,7 +15,7 @@ end
 
 begin
   require_relative 'auto_instrument'
-  Datadog::SingleStepInstrument::LOADED = true
+  Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
   warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end

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

@@ -14,6 +14,11 @@ module Datadog
         class Propagation
           TYPE_FROM = 'RUBY'
           HEADER_NAME = 'CLOUDWISE'
+          HEADER_OTHER_NAME = 'CLOUDWISE-OTHER'
+
+          # 服务类型
+          SERVICE_TYPE_APPLICATION = 'APPLICATION'
+          SERVICE_TYPE_TASK = 'task'
 
           # CLOUDWISE 字段索引
           FIELD_TYPE_FROM = 0
@@ -27,6 +32,10 @@ module Datadog
           FIELD_SEGMENT_ID = 8
           FIELD_APP_NAME = 9
 
+          # CLOUDWISE-OTHER 字段索引
+          FIELD_OTHER_SERVICE_TYPE_FROM = 0
+          FIELD_OTHER_PARENT_SYS = 1
+
           # 注入 CLOUDWISE 请求头
           # @param span [Datadog::Tracing::SpanOperation] 当前 span
           # @param trace [Datadog::Tracing::TraceOperation] 当前 trace
@@ -41,6 +50,9 @@ module Datadog
             # 获取目标 URL
             target_url = extract_target_url(request)
 
+            # 生成 assumed_app_id
+            assumed_app_id = generate_assumed_app_id(target_url)
+
             # 构建 CLOUDWISE header 值
             cloudwise_value = build_cloudwise_value(
               span: span,
@@ -52,6 +64,14 @@ module Datadog
             # 添加到请求头
             request[HEADER_NAME] = cloudwise_value if cloudwise_value
 
+            # 注入 CLOUDWISE-OTHER 请求头
+            inject_other_header!(request)
+
+            # 将 assumed_app_id 添加到 span 的 tags 中
+            if assumed_app_id && assumed_app_id != '-1'
+              span.set_tag('assumed_app_id', assumed_app_id)
+            end
+
             Datadog.logger.debug do
               "Injected CLOUDWISE header: #{cloudwise_value}"
             end if defined?(Datadog.logger)
@@ -257,8 +277,7 @@ module Datadog
             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]}"
+              "Extracted CLOUDWISE header : cloudwise_header=#{cloudwise_header}"
             end if defined?(Datadog.logger)
           rescue => e
             Datadog.logger.error do
@@ -288,17 +307,17 @@ module Datadog
               return nil
             end
 
-            # 构建字段哈希
+            # 构建字段哈希（将 "null" 字符串转换为空字符串）
             {
               type_from: parts[FIELD_TYPE_FROM]&.strip,
-              sample: parts[FIELD_SAMPLE]&.strip,
-              host_id: parts[FIELD_HOST_ID]&.strip,
+              sample: normalize_field_value(parts[FIELD_SAMPLE]),
+              host_id: normalize_field_value(parts[FIELD_HOST_ID]),
               app_id: parts[FIELD_APP_ID]&.strip,
-              instance_id: parts[FIELD_INSTANCE_ID]&.strip,
+              instance_id: normalize_field_value(parts[FIELD_INSTANCE_ID]),
               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,
+              segment_id: normalize_field_value(parts[FIELD_SEGMENT_ID]),
               app_name: parts[FIELD_APP_NAME]&.strip
             }
           rescue => e
@@ -307,6 +326,144 @@ module Datadog
             end if defined?(Datadog.logger)
             nil
           end
+
+          # 标准化字段值：去除空格，将 "null" 转换为空字符串
+          # @param value [String, nil] 原始字段值
+          # @return [String] 标准化后的字段值
+          def self.normalize_field_value(value)
+            return '-1' if value.nil?
+
+            normalized = value.strip
+            # 将字符串 "null" 转换为空字符串
+            normalized == 'null' ? '-1' : normalized
+          end
+
+          # 获取当前服务的 sys 值
+          # @return [String] sys 值，默认为 'default'
+          def self.get_sys
+            ENV['CW_SYS'] || 'default'
+          end
+
+          # 生成 service_instance_id（基于 IP + 进程路径 + PID）
+          # @return [String] service_instance_id
+          def self.generate_service_instance_id
+            host_ip = get_host_ip
+            process_path = $PROGRAM_NAME || ''
+            process_pid = Process.pid.to_s
+
+            # 组合：IP + 进程路径 + PID
+            combined = "#{host_ip}#{process_path}#{process_pid}"
+
+            # 使用 MD5 生成唯一 ID
+            require 'digest/md5'
+            md5_hex = Digest::MD5.hexdigest(combined)
+            # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+            md5_hex[0..14].to_i(16).to_s
+          rescue => e
+            Datadog.logger.debug { "Error generating service_instance_id: #{e.message}" } if defined?(Datadog.logger)
+            # 降级方案：使用 PID
+            Process.pid.to_s
+          end
+
+          # 检测当前服务类型
+          # @return [String] 服务类型：'APPLICATION' 或 'task'
+          def self.detect_service_type
+            # 优先检查环境变量显式设置
+            service_type_env = ENV['CLOUDWISE_SERVICE_TYPE']
+            if service_type_env
+              return SERVICE_TYPE_TASK if service_type_env.downcase == 'task'
+              return SERVICE_TYPE_APPLICATION if service_type_env.downcase == 'application'
+            end
+
+            # 检查是否在 Worker 进程中运行（更精确的判断）
+            # Sidekiq Worker 进程（检查 Sidekiq 是否作为服务器运行）
+            if defined?(::Sidekiq) && ::Sidekiq.respond_to?(:server?) && ::Sidekiq.server?
+              return SERVICE_TYPE_TASK
+            end
+
+            # Resque Worker 进程
+            if defined?(::Resque) && ENV['QUEUE']
+              return SERVICE_TYPE_TASK
+            end
+
+            # DelayedJob Worker 进程
+            if defined?(::Delayed::Worker) && ENV['DELAYED_JOB']
+              return SERVICE_TYPE_TASK
+            end
+
+            # 显式的 Worker 模式
+            if ENV['WORKER_MODE'] == 'true'
+              return SERVICE_TYPE_TASK
+            end
+
+            # 默认为 Web 应用
+            SERVICE_TYPE_APPLICATION
+          rescue => e
+            # 如果检测出错，默认为 Web 应用
+            Datadog.logger.debug { "Error detecting service type: #{e.message}, defaulting to APPLICATION" } if defined?(Datadog.logger)
+            SERVICE_TYPE_APPLICATION
+          end
+
+          # 注入 CLOUDWISE-OTHER 请求头到下游服务
+          # @param request [Net::HTTPRequest] HTTP 请求对象
+          def self.inject_other_header!(request)
+            return unless request
+
+            service_type = detect_service_type
+            sys = get_sys
+
+            # 构建 CLOUDWISE-OTHER 值：service_type_from:sys
+            other_value = "#{service_type}:#{sys}"
+            request[HEADER_OTHER_NAME] = other_value
+
+            Datadog.logger.debug do
+              "Injected CLOUDWISE-OTHER header: #{other_value}"
+            end if defined?(Datadog.logger)
+          rescue => e
+            Datadog.logger.error do
+              "Error injecting CLOUDWISE-OTHER header: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
+
+          # 从请求头中提取 CLOUDWISE-OTHER 并添加到根 span
+          # @param span [Datadog::Tracing::SpanOperation] 根 span
+          # @param request_headers [Hash] 请求头
+          def self.extract_other_from_request!(span, request_headers)
+            return unless span
+
+            # 从请求头中获取 CLOUDWISE-OTHER
+            other_header = request_headers[HEADER_OTHER_NAME] ||
+                          request_headers['HTTP_' + HEADER_OTHER_NAME.upcase.gsub('-', '_')]
+
+            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])
+
+              # 只添加上游相关的字段到 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)
+
+              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', '')
+
+              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
+          rescue => e
+            Datadog.logger.error do
+              "Error extracting CLOUDWISE-OTHER: #{e.message}"
+            end if defined?(Datadog.logger)
+          end
         end
       end
     end