cw-datadog 2.23.0.2 → 2.23.0.4

data/lib/datadog/core/cloudwise/client.rb

@@ -10,22 +10,36 @@ module Datadog
     module Cloudwise
       # HTTP client for Cloudwise API calls
       class Client
-        attr_reader :base_url, :server_name, :license_key, :logger, :account_id
+        attr_reader :base_url, :server_name, :license_key, :logger, :account_id,
+                    :integrated_mode, :token, :token_account_id, :token_user_id,
+                    :agent_instance_id
 
         # Response codes
         CODE_SUCCESS = 1000
         CODE_PROBE_SUSPENDED = 1001  # 探针熔断
         CODE_PROBE_ACTIVE = 1002     # 探针活跃/恢复
         CODE_LICENSE_INVALID = 2001  # License 校验失败
+        # DOCC response codes
+        DOCC_CODE_SUCCESS = 100000
 
-        def initialize(base_url:, server_name:, license_key:, logger:)
+        def initialize(base_url:, server_name:, license_key:, logger:, integrated_mode: true, token: nil, api_prefix: nil, api_prefix_mode: nil)
           @base_url = normalize_url(base_url)
           @server_name = server_name
           @license_key = license_key
           @logger = logger
+          @integrated_mode = integrated_mode
+          @token = token
+          @api_prefix = api_prefix  # 自定义 API 路径前缀
+          @api_prefix_mode = api_prefix_mode  # API 前缀模式（简化配置）
           @host_id = nil
           @account_id = nil
           @is_first_heartbeat = true
+
+          # Parse token if provided
+          parse_token if @token && !@token.empty?
+
+          # Generate agent instance ID for DOCC
+          @agent_instance_id = generate_agent_id(get_local_ip) if use_integrated_mode?
         end
 
         # 工厂方法：从 Datadog settings 创建 Client
@@ -47,7 +61,11 @@ module Datadog
             base_url: base_url,
             server_name: settings.service || 'unknown-service',
             license_key: settings.cloudwise.license_key,
-            logger: logger
+            logger: logger,
+            integrated_mode: settings.cloudwise.integrated_mode,
+            token: settings.cloudwise.token,
+            api_prefix: settings.cloudwise.api_prefix,
+            api_prefix_mode: settings.cloudwise.api_prefix_mode
           )
         end
 
@@ -181,6 +199,22 @@ module Datadog
           })
         end
 
+        # 熔断状态上报接口
+        # @param fuse_state [Integer] 熔断状态码
+        # @param fuse_describe [String] 熔断描述
+        def report_fuse_state(fuse_state:, fuse_describe:)
+          host_ip = get_local_ip
+
+          post('/api/v1/agent/fuseHeart', {
+            version: Datadog::VERSION::STRING,
+            accountId: @account_id,
+            agentId: generate_agent_id(host_ip),
+            fuseState: fuse_state,
+            fuseDescribe: fuse_describe,
+            appId: generate_app_id(server_name)
+          })
+        end
+
         # 应用注册接口
         def register_application
           host_ip = get_local_ip
@@ -210,11 +244,94 @@ module Datadog
           })
         end
 
+        # Check if should use integrated mode (DOCC interfaces)
+        # 判断是否需要使用融合模式
+        # token不为空且integrated_mode=true时启用
+        def use_integrated_mode?
+          @integrated_mode && @token && !@token.empty? && @token_account_id && @token_user_id
+        end
+
+        # ====================================================================
+        # DOCC Interface Methods (Integrated Mode)
+        # ====================================================================
+
+        # DOCC 注册纳管接口
+        # 接口路径: api/ext/gaia/daemon/registExt
+        # 调用频率: 每10分钟一次
+        def docc_register_ext
+          host_ip = get_local_ip
+
+          data = {
+            agent_instance_id: generate_agent_id(host_ip),
+            agent_id: 'rubyagent',
+            version: 'v' + Datadog::VERSION::STRING,
+            agent_pid: Process.pid,
+            agent_run_user: get_run_user,
+            log_path: get_log_path,
+            ip_address: host_ip,
+            host_name: Socket.gethostname,
+            system_uuid: get_system_uuid,
+            os: get_os_name,
+            arch: get_architecture,
+            meta_info: {
+              app_name: @server_name,
+              service_path: get_process_path,
+              sample: calculate_sample_rate,
+              physical_ip: detect_container? ? get_host_real_ip : '',
+              container_id: detect_container? ? get_container_id : '',
+              sys: ENV['CW_SYS'] || 'default',
+              env_tag: Datadog.configuration.env || 'default'
+            }
+          }
+
+          post_docc('/api/ext/gaia/daemon/registExt', data)
+        end
+
+        # DOCC 心跳纳管接口
+        # 接口路径: api/ext/gaia/daemon/heartbeatExt
+        # 调用频率: 每30秒一次
+        def docc_heartbeat_ext(fusing: false, fusing_condition: nil, fusing_start_time: nil, fusing_end_time: nil)
+          host_ip = get_local_ip
+
+          data = {
+            agent_id: 'rubyagent',
+            agent_instance_id: generate_agent_id(host_ip),
+            agent_pid: Process.pid,
+            agent_run_user: get_run_user,
+            fusing: fusing,
+            fusing_condition: fusing_condition,
+            fusing_start_time: fusing_start_time,
+            fusing_end_time: fusing_end_time
+          }
+
+          post_docc('/api/ext/gaia/daemon/heartbeatExt', data)
+        end
+
+        # DOCC 操作拉取接口
+        # 接口路径: api/ext/gaia/daemon/fetchExt/${agentInstanceId}
+        # 调用频率: 每30秒一次
+        def docc_fetch_operation
+          post_docc("/api/ext/gaia/daemon/fetchExt/#{@agent_instance_id}", {})
+        end
+
+        # DOCC 操作结果上报接口
+        # 接口路径: api/ext/gaia/daemon/report/${agentInstanceId}
+        # 上报操作结果（支持批量上报）
+        # @param results [Array<Hash>, Hash] 单个结果或结果数组
+        def docc_report_operation(results)
+          # 如果传入的是数组，直接使用；否则包装成数组
+          data = results.is_a?(Array) ? results : [results]
+
+          post_docc("/api/ext/gaia/daemon/report/#{@agent_instance_id}", data)
+        end
+
         private
 
         def post(path, data)
-          uri = URI.join(base_url, path)
+          # 统一处理 API 路径前缀
+          path = apply_api_prefix(path)
 
+          uri = URI.join(base_url, path)
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = (uri.scheme == 'https')
           http.open_timeout = 5
@@ -248,7 +365,7 @@ module Datadog
               success: true,
               data: body['data'] || body,
               code: code,
-              message: body['message']
+              message: body['msg']
             }
           when 400..499
             Cloudwise.log_warn { "Cloudwise API client error for #{path}: #{response.code} #{response.body}" }
@@ -262,17 +379,6 @@ module Datadog
           end
         end
 
-        def detect_framework
-          if defined?(::Rails)
-            'rails'
-          elsif defined?(::Sinatra)
-            'sinatra'
-          elsif defined?(::Rack)
-            'rack'
-          else
-            'unknown'
-          end
-        end
 
         # 获取本机 IP 地址
         # 优先获取外网 IP（通过创建 UDP 连接，不实际发送数据）
@@ -287,7 +393,6 @@ module Datadog
             udp_socket.connect('8.8.8.8', 1)
             local_ip = udp_socket.addr.last
             udp_socket.close
-
             return local_ip
           rescue => e
             Cloudwise.log_debug { "Cloudwise: Failed to get IP via UDP: #{e.message}" }
@@ -416,16 +521,34 @@ module Datadog
           ''
         end
 
-        # 计算采样率（借鉴 Propagation 的规则，不引用 tracing 组件）
+        # 计算采样率（读取 Datadog 配置或环境变量）
+        # 返回 0-100 的整数值
         def calculate_sample_rate
-          # 默认采样率为 1（100% 采样）
-          # 可以从环境变量读取自定义采样率
-          rate = ENV['CLOUDWISE_SAMPLE_RATE']&.to_i
-          return rate if rate && rate >= 0 && rate <= 100
+          rate = nil
+
+          # 1. 尝试从 Datadog 配置读取（0.0-1.0 的浮点数）
+          if defined?(Datadog.configuration) &&
+             Datadog.configuration.respond_to?(:tracing) &&
+             Datadog.configuration.tracing.respond_to?(:sampling) &&
+             Datadog.configuration.tracing.sampling.respond_to?(:default_rate)
+            configured_rate = Datadog.configuration.tracing.sampling.default_rate
+            rate = configured_rate if configured_rate && configured_rate >= 0.0 && configured_rate <= 1.0
+          end
 
-          1  # 默认值
-        rescue
-          1
+          # 2. 尝试从环境变量读取（DD_TRACE_SAMPLE_RATE，0.0-1.0 的浮点数）
+          if rate.nil? && ENV['DD_TRACE_SAMPLE_RATE']
+            env_rate = ENV['DD_TRACE_SAMPLE_RATE'].to_f
+            rate = env_rate if env_rate >= 0.0 && env_rate <= 1.0
+          end
+
+          # 3. 如果没有配置，默认使用 100%
+          rate = 1.0 if rate.nil?
+
+          # 转换为 0-100 的整数
+          (rate * 100).to_i
+        rescue => e
+          Cloudwise.log_debug { "Failed to calculate sample rate: #{e.message}" }
+          100 # 出错时默认 100%
         end
 
         # 生成标识（基于多个因素的唯一标识）
@@ -484,6 +607,270 @@ module Datadog
           url.chomp('/')
         end
 
+        # 统一处理 API 路径前缀
+        # 优先级：api_prefix_mode > api_prefix > integrated_mode (/apm) > 无前缀
+        # @param path [String] 原始路径
+        # @return [String] 处理后的路径
+        def apply_api_prefix(path)
+          # DOCC 接口不需要添加前缀（它们有自己的路径）
+          return path if path.start_with?('/api/ext/gaia/daemon/')
+
+          # 获取需要应用前缀的路径
+          # 这些路径是 Cloudwise 特定的API，不是 DOCC 接口
+          cloudwise_api_paths = [
+            '/v2/app/generateHostId',
+            '/v2/app/registerHost',
+            '/api/v1/agent/heartbeat',
+            '/api/v1/agent/fuseHeart',
+            '/v2/app/create',
+            '/v2/licence/verification'
+          ]
+
+          # 检查是否是需要添加前缀的路径
+          needs_prefix = cloudwise_api_paths.any? { |p| path.start_with?(p) }
+          return path unless needs_prefix
+
+          # 优先级 1: api_prefix_mode 模式配置（最高优先级，简化配置）
+          if @api_prefix_mode && !@api_prefix_mode.empty?
+            prefix = get_prefix_by_mode(@api_prefix_mode)
+            return "#{prefix}#{path}" if prefix
+          end
+
+          # 优先级 2: 显式配置的 api_prefix（自定义前缀）
+          if @api_prefix && !@api_prefix.empty?
+            prefix = @api_prefix.start_with?('/') ? @api_prefix : "/#{@api_prefix}"
+            return "#{prefix}#{path}"
+          end
+
+          # 优先级 3: integrated_mode 使用 /apm 前缀
+          if use_integrated_mode?
+            return "/apm#{path}"
+          end
+
+          # 优先级 4: 无前缀（默认）
+          path
+        end
+
+        # 根据模式获取前缀
+        # @param mode [String] 前缀模式：'doop', 'apm', 'custom'
+        # @return [String, nil] 前缀字符串，如果模式无效返回 nil
+        def get_prefix_by_mode(mode)
+          case mode.to_s.downcase
+          when 'doop'
+            '/doop-agent-api'
+          when 'apm'
+            '/apm'
+          when 'custom'
+            # 使用 api_prefix 配置的自定义前缀
+            if @api_prefix && !@api_prefix.empty?
+              @api_prefix.start_with?('/') ? @api_prefix : "/#{@api_prefix}"
+            else
+              Cloudwise.log_warn { "Cloudwise: api_prefix_mode='custom' but api_prefix is not set" }
+              nil
+            end
+          else
+            Cloudwise.log_warn { "Cloudwise: Unknown api_prefix_mode '#{mode}', ignoring" }
+            nil
+          end
+        end
+
+        # Parse token to extract account_id and user_id
+        # Token format: base64("account_id@user_id")
+        def parse_token
+          require 'base64'
+
+          begin
+            decoded = Base64.decode64(@token)
+            parts = decoded.split('@')
+
+            if parts.length == 2 && !parts[0].empty? && !parts[1].empty?
+              @token_account_id = parts[0]
+              @token_user_id = parts[1]
+              @account_id = @token_account_id
+              Cloudwise.log_debug { "Cloudwise: Token parsed - account_id: #{@token_account_id}, user_id: #{@token_user_id}" }
+
+              #account_id
+              ENV['CLOUDWISE_ACCOUNT_ID'] = @token_account_id.to_s
+            else
+              Cloudwise.log_warn { 'Cloudwise: Invalid token format (expected base64 of account_id@user_id)' }
+              @token_account_id = nil
+              @token_user_id = nil
+            end
+          rescue => e
+            Cloudwise.log_error { "Cloudwise: Failed to parse token: #{e.message}" }
+            @token_account_id = nil
+            @token_user_id = nil
+          end
+        end
+
+
+        # Get current run user
+        def get_run_user
+          ENV['USER'] || ENV['USERNAME'] || 'cloudwise'
+        rescue
+          'cloudwise'
+        end
+
+        # Get log path
+        def get_log_path
+          if defined?(Datadog.logger) && Datadog.logger.respond_to?(:logdev)
+            logdev = Datadog.logger.logdev
+            return logdev.filename if logdev.respond_to?(:filename) && logdev.filename
+          end
+          ''
+        rescue
+          ''
+        end
+
+
+        # Get system UUID
+        # Try multiple methods to get a unique system identifier
+        def get_system_uuid
+          # Method 1: Try to read from /etc/machine-id (Linux)
+          if File.exist?('/etc/machine-id')
+            uuid = File.read('/etc/machine-id').strip
+            return uuid unless uuid.empty?
+          end
+
+          # Method 2: Try to read from /var/lib/dbus/machine-id (Linux)
+          if File.exist?('/var/lib/dbus/machine-id')
+            uuid = File.read('/var/lib/dbus/machine-id').strip
+            return uuid unless uuid.empty?
+          end
+
+          # Method 3: Try macOS system_profiler
+          if RUBY_PLATFORM =~ /darwin/
+            uuid = `system_profiler SPHardwareDataType 2>/dev/null | awk '/UUID/ { print $3; }'`.strip
+            return uuid unless uuid.empty?
+          end
+
+          # Method 4: Generate a persistent UUID based on hostname and mac address
+          generate_uuid_from_system_info
+        rescue => e
+          Cloudwise.log_debug { "Failed to get system UUID: #{e.message}" }
+          # Fallback: generate a UUID from hostname
+          generate_fallback_uuid
+        end
+
+        # Generate UUID from system information
+        def generate_uuid_from_system_info
+          require 'digest/md5'
+          hostname = get_safe_hostname
+          mac = get_mac_address
+          combined = "#{hostname}-#{mac}"
+          Digest::MD5.hexdigest(combined)
+        end
+
+        # Generate fallback UUID
+        def generate_fallback_uuid
+          require 'digest/md5'
+          hostname = get_safe_hostname
+          Digest::MD5.hexdigest(hostname)
+        end
+
+        # Get hostname safely
+        def get_safe_hostname
+          Socket.gethostname
+        rescue
+          'unknown'
+        end
+
+        # Get MAC address
+        def get_mac_address
+          # Try to get MAC address from network interfaces
+          if File.exist?('/sys/class/net')
+            Dir.glob('/sys/class/net/*/address').each do |addr_file|
+              next if addr_file.include?('lo') # Skip loopback
+              mac = File.read(addr_file).strip
+              return mac unless mac.empty? || mac == '00:00:00:00:00:00'
+            end
+          end
+
+          # Fallback: try ifconfig/ip command
+          output = `ifconfig 2>/dev/null || ip link show 2>/dev/null`.strip
+          match = output.match(/(?:[0-9a-f]{2}:){5}[0-9a-f]{2}/i)
+          return match[0] if match
+
+          ''
+        rescue
+          ''
+        end
+
+        # Get OS name
+        def get_os_name
+          case RUBY_PLATFORM
+          when /linux/
+            'Linux'
+          when /darwin/
+            'Darwin'
+          when /freebsd/
+            'FreeBSD'
+          when /netbsd/
+            'NetBSD'
+          when /openbsd/
+            'OpenBSD'
+          when /sunos|solaris/
+            'Solaris'
+          when /aix/
+            'AIX'
+          when /win|mingw|mswin/
+            'Windows'
+          else
+            RUBY_PLATFORM
+          end
+        rescue
+          'Unknown'
+        end
+
+        # Get system architecture
+        def get_architecture
+          case RbConfig::CONFIG['host_cpu']
+          when /x86_64|amd64/
+            'x86_64'
+          when /i[3-6]86|x86/
+            'x86'
+          when /aarch64|arm64/
+            'aarch_64'
+          when /arm/
+            'arm'
+          when /ppc64le/
+            'ppc64le'
+          when /ppc64/
+            'ppc64'
+          when /s390x/
+            's390x'
+          else
+            RbConfig::CONFIG['host_cpu']
+          end
+        rescue
+          'unknown'
+        end
+
+        # POST request for DOCC interfaces with token authentication
+        def post_docc(path, data)
+          uri = URI.join(base_url, path)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == 'https')
+          http.open_timeout = 5
+          http.read_timeout = 5
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['token'] = @token
+          request['User-Agent'] = "Datadog-Ruby-Agent/#{Datadog::VERSION::STRING}"
+          request['DD-Internal-Untraced-Request'] = '1'
+          request.body = data.to_json
+
+          Cloudwise.log_debug { "Cloudwise DOCC API request: #{request.method} #{uri} with data: #{data.inspect}" }
+
+          response = http.request(request)
+          handle_response(response, path)
+        rescue => e
+          Cloudwise.log_error { "Cloudwise DOCC API error for #{path}: #{e.class.name} #{e.message}" }
+          { success: false, error: e.message, code: nil }
+        end
+
       end
     end
   end