cw-datadog 2.23.0.2

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that registers application every 3 minutes
+      # 应用注册失败不影响数据采集
+      class AppRegistrationWorker < Worker
+        include Workers::Polling
+
+        # 3 minutes interval
+        DEFAULT_INTERVAL = 180
+        # 成功的状态码
+        CODE_SUCCESS = 1000
+
+        attr_reader :client
+
+        def initialize(client:, logger:, probe_state:, **options)
+          @client = client
+          @logger = logger
+          @probe_state = probe_state
+          @registration_successful = false
+
+          # Workers::Async::Thread settings
+          self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
+
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = options.fetch(:interval, DEFAULT_INTERVAL)
+
+          self.enabled = options.fetch(:enabled, true)
+        end
+
+        def perform
+          # Wait for Host ID to be generated
+          unless client.account_id
+            Cloudwise.log_debug { 'Cloudwise: Waiting for Host ID generation before application registration' }
+            return true
+          end
+
+          Cloudwise.log_debug { 'Cloudwise: Registering application' }
+
+          result = client.register_application
+
+          process_registration_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: Application registration worker error: #{e.class.name} #{e.message}" }
+          @probe_state.mark_app_unregistered!
+          true # Continue running
+        end
+
+        def registered?
+          @registration_successful
+        end
+
+        # Public method to start the worker
+        def start
+          return false if !enabled? || started?
+
+          # Start the async worker thread
+          perform
+        end
+
+        private
+
+        attr_reader :logger, :probe_state
+
+        def process_registration_result(result)
+          # 接口请求成功且 code == 1000
+          if result[:success] && result[:code] == CODE_SUCCESS
+            @registration_successful = true
+            Cloudwise.log_debug { 'Cloudwise: Application registration successful' }
+            probe_state.mark_app_registered!
+          else
+            @registration_successful = false
+            error_msg = result[:error] || "code=#{result[:code]}"
+            Cloudwise.log_warn { "Cloudwise: Application registration failed: #{error_msg}, will retry in #{DEFAULT_INTERVAL}s" }
+            Cloudwise.log_warn { 'Cloudwise: Note - Registration failure does NOT affect data collection' }
+            probe_state.mark_app_unregistered!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,490 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'socket'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # HTTP client for Cloudwise API calls
+      class Client
+        attr_reader :base_url, :server_name, :license_key, :logger, :account_id
+
+        # Response codes
+        CODE_SUCCESS = 1000
+        CODE_PROBE_SUSPENDED = 1001  # 探针熔断
+        CODE_PROBE_ACTIVE = 1002     # 探针活跃/恢复
+        CODE_LICENSE_INVALID = 2001  # License 校验失败
+
+        def initialize(base_url:, server_name:, license_key:, logger:)
+          @base_url = normalize_url(base_url)
+          @server_name = server_name
+          @license_key = license_key
+          @logger = logger
+          @host_id = nil
+          @account_id = nil
+          @is_first_heartbeat = true
+        end
+
+        # 工厂方法：从 Datadog settings 创建 Client
+        # 使用 AgentSettingsResolver 来正确处理 SSL 配置
+        #
+        # @param settings [Datadog::Core::Configuration::Settings] Datadog 配置对象
+        # @param logger [Logger] 日志记录器
+        # @return [Client] 新的 Client 实例
+        def self.from_settings(settings, logger: Datadog.logger)
+          require_relative '../configuration/agent_settings_resolver'
+
+          # 使用 AgentSettingsResolver 解析 agent 配置（包括 SSL）
+          agent_settings = Configuration::AgentSettingsResolver.call(settings, logger: logger)
+
+          # 构建 base_url（自动处理 http/https）
+          base_url = build_url_from_agent_settings(agent_settings)
+
+          new(
+            base_url: base_url,
+            server_name: settings.service || 'unknown-service',
+            license_key: settings.cloudwise.license_key,
+            logger: logger
+          )
+        end
+
+        # 从 AgentSettings 构建 URL
+        # @param agent_settings [Datadog::Core::Configuration::AgentSettings]
+        # @return [String] 完整的 URL (http:// 或 https://)
+        def self.build_url_from_agent_settings(agent_settings)
+          # AgentSettings.url 已经包含了完整的 URL（包括协议）
+          # 格式: "http://127.0.0.1:8126/" 或 "https://127.0.0.1:8126/"
+          agent_settings.url.chomp('/')  # 移除末尾的斜杠
+        end
+        private_class_method :build_url_from_agent_settings
+
+        # 生成 Host ID 接口（第一步）
+        def generate_host_id
+          host_ip = get_local_ip
+
+          response = post('/v2/app/generateHostId', {
+            host_ip: host_ip,
+            app_type: 1,
+            license_key: license_key
+          })
+
+          if response[:success] && response[:data] && response[:data]['hostId']
+            @host_id = response[:data]['hostId']
+
+            # 第二步：注册 Host 获取 account_id
+            register_response = register_host(host_ip)
+
+            if register_response[:success] && register_response[:data] && register_response[:data]['account_id']
+              @account_id = register_response[:data]['account_id'].to_i
+
+              # 设置到环境变量 (转为字符串存储)
+              ENV['CLOUDWISE_ACCOUNT_ID'] = @account_id.to_s
+              ENV['CLOUDWISE_HOST_ID'] = @host_id.to_s
+              ENV['CLOUDWISE_AGENT_ID'] = generate_agent_id(host_ip).to_s
+              ENV['CLOUDWISE_HOST_NAME'] = Socket.gethostname rescue 'unknown'
+              ENV['CLOUDWISE_INSTANCE_ID'] = generate_service_instance_id(host_ip).to_s
+
+              Cloudwise.log_debug { "Cloudwise: Registered Host, account_id: #{@account_id}, host_id: #{@host_id}" }
+              # 返回 register_host 的响应（包含 account_id）
+              return register_response
+            else
+              error_msg = register_response[:error] || "code=#{register_response[:code]}"
+              Cloudwise.log_error { "Cloudwise: Failed to register host: #{error_msg}" }
+              return register_response
+            end
+          else
+            error_msg = response[:error] || "No hostId in response"
+            Cloudwise.log_error { "Cloudwise: Failed to generate host ID: #{error_msg}" }
+          end
+
+          response
+        end
+
+        # 注册 Host 接口（第二步）
+        def register_host(host_ip)
+          unless @host_id
+            Cloudwise.log_error { 'Cloudwise: Cannot register host without host_id' }
+            return { success: false, error: 'host_id not generated', code: nil }
+          end
+
+          # 获取系统信息
+          host_name = Socket.gethostname rescue 'default'
+          sys_version = RUBY_VERSION
+
+          post('/v2/app/registerHost', {
+            host_ip: host_ip,
+            license_key: license_key,
+            host_id: @host_id,
+            host_name: host_name,
+            host_type: 1,
+            cluster_name: '',
+            sys_version: sys_version
+          })
+        end
+
+        # 心跳接口
+        def heartbeat
+          host_ip = get_local_ip
+          host_name = Socket.gethostname rescue 'unknown'
+
+          post('/api/v1/agent/heartbeat', {
+            version: Datadog::VERSION::STRING,
+            accountId: @account_id,
+            hostId: @host_id,
+            plugId: '1012',
+            omniAgent: 0,
+            imagePath: get_agent_path,
+            ip: host_ip,
+            agentId: generate_agent_id(host_ip),
+            timestamp: Time.now.to_i,
+            routingKey: 'HeartBeat',
+            classPath: '',
+            isFirst: @is_first_heartbeat ? 1 : 0,
+            app_name: server_name,
+            appId: generate_app_id(server_name),
+            physical_sip: host_ip,
+            process_path: get_process_path,
+            hostName: host_name,
+            isContainer: detect_container? ? 1 : 0,
+            hostRealIp: detect_container? ? get_host_real_ip : host_ip,
+            hostNameAlias: detect_container? ? get_host_alias : host_name,
+            containerId: detect_container? ? get_container_id : '',
+            sample: calculate_sample_rate,
+            pid: Process.pid,
+            identification: generate_identification,
+            env: 'env',
+            service: 'service',
+            business: '',
+            sys: '',
+            hostTag: '{}',
+            tags: {},
+            systemUuid: '',
+            serviceInstanceId: generate_service_instance_id(host_ip)
+          }).tap do
+            @is_first_heartbeat = false if @is_first_heartbeat
+          end
+        end
+
+        # License 校验接口
+        def verify_license
+          host_ip = get_local_ip
+
+          post('/v2/licence/verification', {
+            account_id: (@account_id).to_s,
+            agent_id: generate_agent_id(host_ip),
+            service_type: 'RUBY',
+            version: Datadog::VERSION::STRING,
+            env_tag: Datadog.configuration.env
+          })
+        end
+
+        # 应用注册接口
+        def register_application
+          host_ip = get_local_ip
+
+          post('/v2/app/create', {
+            serviceType: 'RUBY',
+            accountId: @account_id,
+            hostId: @host_id.to_i,
+            agentId: generate_agent_id(host_ip).to_i,
+            appId: generate_app_id(server_name).to_i,
+            sn: host_ip,
+            sport: get_server_port,
+            appName: server_name,
+            userDirRaw: server_name,
+            codeType: 1012,
+            app_type: 1,
+            vpc: '',
+            env_tag:  'default',
+            service_tag:  'default',
+            version_tag:'default',
+            business_tag: '' ,
+            sys: '',
+            host_tag: '{}',
+            tags: {},
+            service_instance_id: generate_service_instance_id(host_ip).to_i,
+            system_uuid: ''
+          })
+        end
+
+        private
+
+        def post(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['User-Agent'] = "Datadog-Ruby-Agent/#{Datadog::VERSION::STRING}"
+          # 添加 Datadog 内部 header，让 Net::HTTP instrumentation 跳过 tracing
+          # 这可以避免在 tracer 未初始化时触发 NoMethodError
+          request['DD-Internal-Untraced-Request'] = '1'
+          request.body = data.to_json
+          Cloudwise.log_debug { "Cloudwise API request:#{request.method} #{uri.to_s} with data: #{data.inspect}" }
+
+          response = http.request(request)
+          handle_response(response, path)
+        rescue => e
+          Cloudwise.log_error { "Cloudwise API error for #{path}: #{e.class.name} #{e.message}" }
+          { success: false, error: e.message, code: nil }
+        end
+
+        def handle_response(response, path)
+          case response.code.to_i
+          when 200..299
+            body = JSON.parse(response.body) rescue {}
+            code = body['code'] || body['status_code']
+
+            Cloudwise.log_debug { "Cloudwise API response for #{path}: code=#{code}, body=#{body.inspect}" }
+
+            {
+              success: true,
+              data: body['data'] || body,
+              code: code,
+              message: body['message']
+            }
+          when 400..499
+            Cloudwise.log_warn { "Cloudwise API client error for #{path}: #{response.code} #{response.body}" }
+            { success: false, error: "Client error: #{response.code}", code: nil }
+          when 500..599
+            Cloudwise.log_error { "Cloudwise API server error for #{path}: #{response.code} #{response.body}" }
+            { success: false, error: "Server error: #{response.code}", code: nil }
+          else
+            Cloudwise.log_warn { "Cloudwise API unexpected response for #{path}: #{response.code}" }
+            { success: false, error: "Unexpected response: #{response.code}", code: nil }
+          end
+        end
+
+        def detect_framework
+          if defined?(::Rails)
+            'rails'
+          elsif defined?(::Sinatra)
+            'sinatra'
+          elsif defined?(::Rack)
+            'rack'
+          else
+            'unknown'
+          end
+        end
+
+        # 获取本机 IP 地址
+        # 优先获取外网 IP（通过创建 UDP 连接，不实际发送数据）
+        # 如果失败，尝试获取局域网 IP
+        # 最后返回 127.0.0.1
+        def get_local_ip
+          # 方法 1: 通过创建 UDP socket 获取本机对外 IP（推荐）
+          # 这个方法不会实际发送数据包，只是创建一个连接来获取本机 IP
+          begin
+            udp_socket = UDPSocket.new
+            # 连接到一个公网 DNS 服务器（Google DNS）
+            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}" }
+          end
+
+          # 方法 2: 通过 hostname 获取 IP
+          begin
+            hostname = Socket.gethostname
+            local_ip = Socket.getaddrinfo(hostname, nil, Socket::AF_INET).first[3]
+
+            # 排除 localhost
+            unless local_ip.start_with?('127.')
+              Cloudwise.log_debug { "Cloudwise: Detected local IP via hostname: #{local_ip}" }
+              return local_ip
+            end
+          rescue => e
+            Cloudwise.log_debug { "Cloudwise: Failed to get IP via hostname: #{e.message}" }
+          end
+
+          # 方法 3: 遍历网络接口（Linux/Unix）
+          begin
+            Socket.ip_address_list.each do |addr|
+              # 只要 IPv4 地址，排除 loopback 和 link-local
+              if addr.ipv4? && !addr.ipv4_loopback? && !addr.ipv4_private?
+                Cloudwise.log_debug { "Cloudwise: Detected local IP via interfaces (public): #{addr.ip_address}" }
+                return addr.ip_address
+              end
+            end
+
+            # 如果没有公网 IP，尝试获取私有 IP
+            Socket.ip_address_list.each do |addr|
+              if addr.ipv4? && !addr.ipv4_loopback? && addr.ipv4_private?
+                Cloudwise.log_debug { "Cloudwise: Detected local IP via interfaces (private): #{addr.ip_address}" }
+                return addr.ip_address
+              end
+            end
+          rescue => e
+            Cloudwise.log_debug { "Cloudwise: Failed to get IP via interfaces: #{e.message}" }
+          end
+
+        end
+
+        # 获取 Agent 路径
+        def get_agent_path
+          File.dirname(__FILE__)
+        rescue
+          ''
+        end
+
+        # 生成 Agent ID（基于 host_ip 的 MD5）
+        def generate_agent_id(host_ip)
+          require 'digest/md5'
+          # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+          # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+          Digest::MD5.hexdigest(host_ip)[0..14].to_i(16).to_s
+        rescue
+          Process.pid.to_s
+        end
+
+        # 生成 app_id（借鉴 Propagation 的生成规则，不引用 tracing 组件）
+        def generate_app_id(service_name)
+          return '' unless service_name
+
+          require 'digest/md5'
+          # 使用 MD5 哈希生成唯一 ID（与 Propagation 相同的算法）
+          hash = Digest::MD5.hexdigest(service_name)
+          # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+          # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+          hash[0..14].to_i(16).to_s
+        rescue => e
+          Cloudwise.log_debug { "Failed to generate app_id: #{e.message}" }
+          ''
+        end
+
+        # 获取进程路径
+        def get_process_path
+          $PROGRAM_NAME
+        rescue
+          ''
+        end
+
+        # 检测是否为容器环境
+        def detect_container?
+          # 检查 Docker
+          return true if File.exist?('/.dockerenv')
+
+          # 检查 Kubernetes
+          return true if ENV['KUBERNETES_SERVICE_HOST']
+
+          # 检查 cgroup
+          if File.exist?('/proc/1/cgroup')
+            cgroup_content = File.read('/proc/1/cgroup')
+            return true if cgroup_content.include?('docker') || cgroup_content.include?('kubepods')
+          end
+
+          false
+        rescue
+          false
+        end
+
+        # 获取宿主机真实 IP（容器场景）
+        def get_host_real_ip
+          # 尝试从环境变量获取
+          ENV['HOST_IP'] || get_local_ip
+        end
+
+        # 获取宿主机别名（容器场景）
+        def get_host_alias
+          ENV['HOST_NAME'] || Socket.gethostname
+        rescue
+          'unknown'
+        end
+
+        # 获取容器 ID
+        def get_container_id
+          # Docker 容器 ID
+          if File.exist?('/proc/self/cgroup')
+            cgroup_content = File.read('/proc/self/cgroup')
+            match = cgroup_content.match(%r{/docker/([a-f0-9]{64})})
+            return match[1][0..11] if match
+          end
+
+          # Kubernetes Pod ID
+          ENV['HOSTNAME'] || ''
+        rescue
+          ''
+        end
+
+        # 计算采样率（借鉴 Propagation 的规则，不引用 tracing 组件）
+        def calculate_sample_rate
+          # 默认采样率为 1（100% 采样）
+          # 可以从环境变量读取自定义采样率
+          rate = ENV['CLOUDWISE_SAMPLE_RATE']&.to_i
+          return rate if rate && rate >= 0 && rate <= 100
+
+          1  # 默认值
+        rescue
+          1
+        end
+
+        # 生成标识（基于多个因素的唯一标识）
+        def generate_identification
+          require 'digest/md5'
+          combined = "#{Socket.gethostname}#{Process.pid}#{Time.now.to_i}"
+          Digest::MD5.hexdigest(combined)[0..15]
+        rescue
+          "ruby-#{Process.pid}"
+        end
+
+        # 生成服务实例 ID（基于 host_ip + port 的 MD5）
+        def generate_service_instance_id(host_ip)
+          require 'digest/md5'
+          # 获取端口
+          port = get_server_port
+          # 组合 host_ip 和 port 生成唯一实例 ID
+          combined = "#{host_ip}#{port}"
+          hash = Digest::MD5.hexdigest(combined)
+          # 取前15位转为整数（避免超过 Java Long.MAX_VALUE）
+          # 15位十六进制 = 60 bits，最大值 2^60-1 = 1152921504606846975（19位数字）
+          hash[0..14].to_i(16).to_s
+        rescue => e
+          Cloudwise.log_debug { "Failed to generate service_instance_id: #{e.message}" }
+          Process.pid.to_s
+        end
+
+        # 获取服务器端口
+        def get_server_port
+          # 尝试从环境变量获取
+          port = ENV['PORT'] || ENV['APP_PORT']
+          return port.to_i if port
+
+          # 默认返回 -1 表示未知
+          -1
+        rescue
+          -1
+        end
+
+        # 标准化 URL 格式
+        # 确保 URL 格式正确，移除末尾斜杠
+        # @param url [String] 原始 URL
+        # @return [String] 标准化后的 URL
+        def normalize_url(url)
+          url = url.to_s.strip
+          return url if url.empty?
+
+          # 如果没有协议，根据端口或默认添加 http
+          unless url.start_with?('http://', 'https://')
+            # 检查是否包含 :443 端口（通常用于 HTTPS）
+            protocol = url.include?(':443') ? 'https' : 'http'
+            url = "#{protocol}://#{url}"
+          end
+
+          # 移除末尾的斜杠
+          url.chomp('/')
+        end
+
+      end
+    end
+  end
+end