cw-datadog 2.23.0.2 → 2.23.0.3

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

@@ -6,6 +6,9 @@ require_relative 'host_id_worker'
 require_relative 'heartbeat_worker'
 require_relative 'license_worker'
 require_relative 'app_registration_worker'
+require_relative 'docc_registration_worker'
+require_relative 'docc_heartbeat_worker'
+require_relative 'docc_operation_worker'
 
 module Datadog
   module Core
@@ -42,7 +45,8 @@ module Datadog
       # Main component that manages Cloudwise workers with proper initialization order
       class Component
         attr_reader :client, :probe_state, :host_id_worker, :heartbeat_worker,
-                    :license_worker, :app_registration_worker, :logger
+                    :license_worker, :app_registration_worker, :logger,
+                    :docc_registration_worker, :docc_heartbeat_worker, :docc_operation_worker
 
         # 类级别的单例锁，确保全局只初始化一次
         @initialization_mutex = Mutex.new
@@ -69,36 +73,15 @@ module Datadog
           # Probe state manager (shared across workers)
           @probe_state = ProbeState.new(logger: logger)
 
-          # 1. Host ID Worker (must run first, 30s retry)
-          @host_id_worker = HostIdWorker.new(
-            client: client,
-            logger: logger,
-            probe_state: probe_state
-          )
-
-          # 2. Heartbeat Worker (60s interval, depends on Host ID)
-          @heartbeat_worker = HeartbeatWorker.new(
-            client: client,
-            logger: logger,
-            probe_state: probe_state,
-            interval: settings.cloudwise.heartbeat_interval
-          )
-
-          # 3. Application Registration Worker (3 min interval, depends on Host ID)
-          @app_registration_worker = AppRegistrationWorker.new(
-            client: client,
-            logger: logger,
-            probe_state: probe_state,
-            interval: settings.cloudwise.app_registration_interval
-          )
-
-          # 4. License Worker (5 min interval, depends on Host ID)
-          @license_worker = LicenseWorker.new(
-            client: client,
-            logger: logger,
-            probe_state: probe_state,
-            interval: settings.cloudwise.license_check_interval
-          )
+          # 判断是否使用融合模式（DOCC）
+          if @client.use_integrated_mode?
+            Cloudwise.log_info { 'Cloudwise: Initializing in DOCC integrated mode' }
+            @probe_state.enable_docc_mode!
+            initialize_docc_workers(settings)
+          else
+            Cloudwise.log_info { 'Cloudwise: Initializing in traditional mode' }
+            initialize_traditional_workers(settings)
+          end
         end
 
         # Initialize Cloudwise asynchronously
@@ -120,7 +103,7 @@ module Datadog
               Cloudwise.log_debug { 'Cloudwise Component already initialized globally' }
             else
               # 检查是否有已存在的单例实例
-              if self.class.singleton_instance && self.class.singleton_instance.host_id_worker.started?
+              if self.class.singleton_instance && instance_already_started?
                 cloudwise_already_started = true
                 Cloudwise.log_debug { 'Initializing Datadog components for this Components instance...' }
               else
@@ -145,12 +128,17 @@ module Datadog
           Cloudwise.log_debug { 'Datadog components initialized (data collection pending ProbeState)' }
         end
 
-        # Start Host ID Worker in background (will retry until success)
-        Cloudwise.log_debug { 'Starting Host ID generation worker (async, infinite retry)...' }
-        @host_id_worker.perform
+        # 根据模式启动不同的 workers
+        if @client.use_integrated_mode?
+          start_docc_workers_when_ready
+        else
+          # Start Host ID Worker in background (will retry until success)
+          Cloudwise.log_debug { 'Starting Host ID generation worker (async, infinite retry)...' }
+          @host_id_worker.perform
 
-        # Start other Cloudwise workers in background
-        start_cloudwise_workers_when_ready
+          # Start other Cloudwise workers in background
+          start_cloudwise_workers_when_ready
+        end
 
         Cloudwise.log_debug { 'Cloudwise Component initialization started (async)' }
 
@@ -196,12 +184,20 @@ module Datadog
         # Stop all workers
         def stop
           return unless @enabled
-          @host_id_worker&.stop(true)
-          @heartbeat_worker&.stop(true)
-          @license_worker&.stop(true)
-          @app_registration_worker&.stop(true)
 
-          Cloudwise.log_debug { 'Cloudwise component stopped' }
+          if @client.use_integrated_mode?
+            @docc_heartbeat_worker&.stop(true)
+            @docc_registration_worker&.stop(true)
+            @docc_operation_worker&.stop(true)
+            @license_worker&.stop(true)
+            Cloudwise.log_debug { 'Cloudwise DOCC component stopped' }
+          else
+            @host_id_worker&.stop(true)
+            @heartbeat_worker&.stop(true)
+            @license_worker&.stop(true)
+            @app_registration_worker&.stop(true)
+            Cloudwise.log_debug { 'Cloudwise component stopped' }
+          end
         end
 
         def enabled?
@@ -220,25 +216,118 @@ module Datadog
           return { enabled: false } unless @enabled
 
           probe_status = probe_state.status
-          {
+          base_status = {
             enabled: true,
-            account_id: client.account_id,
-            host_id_generated: host_id_worker.host_id_generated?,
-            host_id_ready: probe_status[:host_id_ready],
-            heartbeat_active: probe_status[:heartbeat_active],
-            license_valid: probe_status[:license_valid],
-            app_registered: probe_status[:app_registered],
+            integrated_mode: @client.use_integrated_mode?,
             can_collect_data: probe_status[:can_collect_data],
             probe_active: probe_state.active?,
             probe_suspended: probe_state.suspended?,
-            heartbeat_running: heartbeat_worker.running?,
-            license_running: license_worker.running?,
-            app_registration_running: app_registration_worker.running?
+            license_valid: probe_status[:license_valid],
+            license_running: license_worker&.running?
           }
+
+          if @client.use_integrated_mode?
+            base_status.merge(
+              docc_registered: probe_status[:docc_registered],
+              docc_heartbeat_active: probe_status[:docc_heartbeat_active],
+              docc_operation_active: probe_status[:docc_operation_active],
+              docc_heartbeat_running: docc_heartbeat_worker&.running?,
+              docc_registration_running: docc_registration_worker&.running?,
+              docc_operation_running: docc_operation_worker&.running?
+            )
+          else
+            base_status.merge(
+              account_id: client.account_id,
+              host_id_generated: host_id_worker&.host_id_generated?,
+              host_id_ready: probe_status[:host_id_ready],
+              heartbeat_active: probe_status[:heartbeat_active],
+              app_registered: probe_status[:app_registered],
+              heartbeat_running: heartbeat_worker&.running?,
+              app_registration_running: app_registration_worker&.running?
+            )
+          end
         end
 
         private
 
+        # 初始化传统模式的 workers
+        def initialize_traditional_workers(settings)
+          # 1. Host ID Worker (must run first, 30s retry)
+          @host_id_worker = HostIdWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state
+          )
+
+          # 2. Heartbeat Worker (60s interval, depends on Host ID)
+          @heartbeat_worker = HeartbeatWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.heartbeat_interval
+          )
+
+          # 3. Application Registration Worker (3 min interval, depends on Host ID)
+          @app_registration_worker = AppRegistrationWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.app_registration_interval
+          )
+
+          # 4. License Worker (5 min interval, depends on Host ID)
+          @license_worker = LicenseWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.license_check_interval
+          )
+        end
+
+        # 初始化 DOCC 模式的 workers
+        def initialize_docc_workers(settings)
+          # 1. DOCC Registration Worker (10 min interval)
+          @docc_registration_worker = DOCCRegistrationWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.docc_registration_interval
+          )
+
+          # 2. DOCC Heartbeat Worker (30s interval)
+          @docc_heartbeat_worker = DOCCHeartbeatWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.heartbeat_interval
+          )
+
+          # 3. DOCC Operation Worker (30s interval)
+          @docc_operation_worker = DOCCOperationWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.docc_operation_interval
+          )
+
+          # 4. License Worker (5 min interval) - License 校验逻辑保持不变
+          @license_worker = LicenseWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state,
+            interval: settings.cloudwise.license_check_interval
+          )
+        end
+
+        # 检查实例是否已经启动
+        def instance_already_started?
+          if @client.use_integrated_mode?
+            self.class.singleton_instance&.docc_heartbeat_worker&.started?
+          else
+            self.class.singleton_instance&.host_id_worker&.started?
+          end
+        end
+
         # Start a background thread that waits for Host ID to be ready
         # Then starts other Cloudwise workers
         #
@@ -299,6 +388,62 @@ module Datadog
           end
         end
 
+        # Start DOCC workers in background
+        # DOCC 模式启动流程：
+        # 1. 启动 DOCC 心跳 worker
+        # 2. 等待第一次心跳成功
+        # 3. 启动 DOCC 注册 worker
+        # 4. 启动 License worker
+        # 5. 启动 DOCC 操作 worker
+        def start_docc_workers_when_ready
+          Thread.new do
+            Thread.current.name = 'Cloudwise-DOCC-Initializer'
+
+            # ============================================================
+            # STEP 1: Start DOCC Heartbeat worker
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise DOCC: Starting heartbeat worker...' }
+            @docc_heartbeat_worker.start
+
+            # Wait for first successful heartbeat
+            Cloudwise.log_debug { 'Cloudwise DOCC: Waiting for first successful heartbeat...' }
+            until probe_state.docc_heartbeat_active?
+              sleep(1)
+            end
+
+            # ============================================================
+            # STEP 2: Start DOCC Registration worker
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise DOCC: Starting registration worker...' }
+            @docc_registration_worker.start
+
+            # ============================================================
+            # STEP 3: Start License worker
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise DOCC: Starting license worker...' }
+            @license_worker.start
+
+            # Wait for first successful license validation
+            until probe_state.license_valid?
+              sleep(1)
+            end
+
+            # ============================================================
+            # STEP 4: Start DOCC Operation worker
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise DOCC: Starting operation worker...' }
+            @docc_operation_worker.start
+
+            # ============================================================
+            # All validations passed - Probe is now ACTIVE
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise DOCC: Data collection and reporting now enabled.' }
+          rescue => e
+            Cloudwise.log_error { "Cloudwise DOCC: Error in background initializer: #{e.class.name} #{e.message}" }
+            Cloudwise.log_error { e.backtrace.join("\n") }
+          end
+        end
+
         # Synchronously generate Host ID with infinite retry (used by HostIdWorker)
         # This method will BLOCK indefinitely until Host ID is successfully generated
         # Never returns false - only returns when successful

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that sends heartbeat to DOCC every 30 seconds with retry mechanism
+      # DOCC 心跳纳管 Worker
+      # 心跳失败 3 次后标记为无心跳，数据不采集
+      class DOCCHeartbeatWorker < Worker
+        include Workers::Polling
+
+        # 30 seconds interval
+        DEFAULT_INTERVAL = 30
+        # Max retries: 3 times
+        MAX_RETRIES = 3
+        # 成功的状态码
+        DOCC_CODE_SUCCESS = 100000
+
+        attr_reader :client
+
+        def initialize(client:, logger:, probe_state:, **options)
+          @client = client
+          @logger = logger
+          @probe_state = probe_state
+          @failure_count = 0
+
+          # 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
+          Cloudwise.log_debug { 'Cloudwise DOCC: Sending heartbeat' }
+
+          result = client.docc_heartbeat_ext
+
+          process_heartbeat_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise DOCC: Heartbeat worker error: #{e.class.name} #{e.message}" }
+          handle_heartbeat_failure
+          true # Continue running
+        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_heartbeat_result(result)
+          # 接口请求失败
+          unless result[:success]
+            handle_heartbeat_failure
+            return
+          end
+
+          code = result[:code]
+
+          # 接口请求成功，但 code 不是 100000
+          if code != DOCC_CODE_SUCCESS
+            Cloudwise.log_warn { "Cloudwise DOCC: Heartbeat returned code #{code} (expected #{DOCC_CODE_SUCCESS})" }
+            Cloudwise.log_warn { "Cloudwise DOCC: Data collection suspended due to invalid heartbeat code" }
+            probe_state.mark_docc_heartbeat_inactive!
+            @failure_count = 0  # 重置失败计数
+            return
+          end
+
+          # 成功且 code == 100000
+          Cloudwise.log_debug { 'Cloudwise DOCC: Heartbeat successful' }
+          probe_state.mark_docc_heartbeat_active!
+          @failure_count = 0  # 重置失败计数
+        end
+
+        def handle_heartbeat_failure
+          @failure_count += 1
+
+          Cloudwise.log_warn { "Cloudwise DOCC: Heartbeat failed (#{@failure_count}/#{MAX_RETRIES})" }
+
+          if @failure_count >= MAX_RETRIES
+            Cloudwise.log_error { "Cloudwise DOCC: Heartbeat failed #{@failure_count} times, marking as inactive" }
+            Cloudwise.log_error { "Cloudwise DOCC: Data collection suspended due to heartbeat failure" }
+            probe_state.mark_docc_heartbeat_inactive!
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that fetches and executes operations from DOCC every 30 seconds
+      # DOCC 操作纳管 Worker（操作拉取和结果上报）
+      class DOCCOperationWorker < Worker
+        include Workers::Polling
+
+        # 30 seconds interval
+        DEFAULT_INTERVAL = 30
+        # 成功的状态码
+        DOCC_CODE_SUCCESS = 100000
+
+        # Operation types
+        OPERATION_AGENT_START = 'agent_start'
+        OPERATION_AGENT_STOP = 'agent_stop'
+
+        attr_reader :client
+
+        def initialize(client:, logger:, probe_state:, **options)
+          @client = client
+          @logger = logger
+          @probe_state = probe_state
+
+          # 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
+          Cloudwise.log_debug { 'Cloudwise DOCC: Fetching operations' }
+
+          result = client.docc_fetch_operation
+
+          process_operation_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise DOCC: Operation worker error: #{e.class.name} #{e.message}" }
+          true # Continue running
+        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_operation_result(result)
+          # 接口请求失败
+          unless result[:success]
+            Cloudwise.log_error { "Cloudwise DOCC: Failed to fetch operations: #{result[:error]}" }
+            return
+          end
+
+          code = result[:code]
+
+          # 检查响应码
+          if code != DOCC_CODE_SUCCESS
+            Cloudwise.log_warn { "Cloudwise DOCC: Fetch operation returned code #{code} (expected #{DOCC_CODE_SUCCESS})" }
+            return
+          end
+
+          # 获取任务数据（data 是一个数组）
+          tasks = result[:data]
+          return unless tasks && tasks.is_a?(Array)
+
+          # 如果没有任务，直接返回
+          if tasks.empty?
+            Cloudwise.log_debug { "Cloudwise DOCC: No operations to execute" }
+            return
+          end
+
+          # 收集所有任务的执行结果
+          results = []
+
+          # 处理所有任务
+          tasks.each do |task_data|
+            task_result = process_single_task(task_data)
+            results << task_result if task_result
+          end
+
+          # 批量上报结果
+          report_operation_results(results) unless results.empty?
+        end
+
+        def process_single_task(task_data)
+          return nil unless task_data.is_a?(Hash)
+
+          task_id = task_data['taskId']
+          operation = task_data['operate']
+          agent_instance_id = task_data['agentInstanceId']
+
+          Cloudwise.log_debug { "Cloudwise DOCC: Received operation - taskId: #{task_id}, operation: #{operation}" }
+
+          # 执行操作并返回结果
+          execute_operation(task_id, operation, agent_instance_id)
+        rescue => e
+          Cloudwise.log_error { "Cloudwise DOCC: Error processing task #{task_id}: #{e.class.name} #{e.message}" }
+          # 返回失败结果
+          create_operation_result(task_id, 'failed', "Error processing task: #{e.message}")
+        end
+
+        def execute_operation(task_id, operation, agent_instance_id)
+          case operation
+          when OPERATION_AGENT_START
+            handle_agent_start(task_id)
+          when OPERATION_AGENT_STOP
+            handle_agent_stop(task_id)
+          else
+            Cloudwise.log_warn { "Cloudwise DOCC: Unknown operation type: #{operation}" }
+            create_operation_result(task_id, 'failed', "Unknown operation type: #{operation}")
+          end
+        end
+
+        def handle_agent_start(task_id)
+          Cloudwise.log_info { 'Cloudwise DOCC: Executing agent_start operation' }
+
+          begin
+            # 启用数据采集和上报
+            probe_state.mark_docc_operation_active!
+
+            # 返回成功结果
+            create_operation_result(task_id, 'success', 'Agent started successfully')
+          rescue => e
+            Cloudwise.log_error { "Cloudwise DOCC: Failed to execute agent_start: #{e.message}" }
+            create_operation_result(task_id, 'failed', "Failed to start agent: #{e.message}")
+          end
+        end
+
+        def handle_agent_stop(task_id)
+          Cloudwise.log_info { 'Cloudwise DOCC: Executing agent_stop operation' }
+
+          begin
+            # 禁用数据采集和上报
+            probe_state.mark_docc_operation_inactive!
+
+            # 返回成功结果
+            create_operation_result(task_id, 'success', 'Agent stopped successfully')
+          rescue => e
+            Cloudwise.log_error { "Cloudwise DOCC: Failed to execute agent_stop: #{e.message}" }
+            create_operation_result(task_id, 'failed', "Failed to stop agent: #{e.message}")
+          end
+        end
+
+        # 创建单个操作结果
+        def create_operation_result(task_id, status, msg)
+          {
+            code: DOCC_CODE_SUCCESS,
+            taskId: task_id,
+            detail: {
+              msg: msg,
+              agent_instance_id: client.agent_instance_id,
+              agent_id: 'rubyagent'
+            },
+            status: status,
+            timestamp: Time.now.to_i * 1000
+          }
+        end
+
+        # 批量上报操作结果
+        def report_operation_results(results)
+          result = client.docc_report_operation(results)
+
+          if result[:success] && result[:code] == DOCC_CODE_SUCCESS
+            Cloudwise.log_debug { "Cloudwise DOCC: Operation results reported successfully - #{results.size} task(s)" }
+          else
+            Cloudwise.log_error { "Cloudwise DOCC: Failed to report operation results - #{results.size} task(s)" }
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that registers extension to DOCC every 10 minutes
+      # DOCC 注册纳管 Worker
+      class DOCCRegistrationWorker < Worker
+        include Workers::Polling
+
+        # 10 minutes interval (600 seconds)
+        DEFAULT_INTERVAL = 600
+        # 成功的状态码
+        DOCC_CODE_SUCCESS = 100000
+
+        attr_reader :client
+
+        def initialize(client:, logger:, probe_state:, **options)
+          @client = client
+          @logger = logger
+          @probe_state = probe_state
+
+          # 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
+          Cloudwise.log_debug { 'Cloudwise DOCC: Registering extension' }
+
+          result = client.docc_register_ext
+
+          process_registration_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise DOCC: Registration worker error: #{e.class.name} #{e.message}" }
+          true # Continue running
+        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)
+          # 接口请求失败
+          unless result[:success]
+            Cloudwise.log_error { "Cloudwise DOCC: Registration failed: #{result[:error]}" }
+            return
+          end
+
+          code = result[:code]
+
+          # 注册成功 (code == 100000)
+          if code == DOCC_CODE_SUCCESS
+            instance_id = result.dig(:data, 'instanceId')
+            status = result.dig(:data, 'status')
+
+            Cloudwise.log_debug { "Cloudwise DOCC: Registration successful - instanceId: #{instance_id}, status: #{status}" }
+
+            # 标记注册成功
+            probe_state.mark_docc_registered!
+            return
+          end
+
+          # 注册失败 (code != 100000)
+          Cloudwise.log_error { "Cloudwise DOCC: Registration failed with code #{code}" }
+        end
+      end
+    end
+  end
+end
+