cw-datadog 2.23.0.2

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

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+require_relative 'probe_state'
+require_relative 'host_id_worker'
+require_relative 'heartbeat_worker'
+require_relative 'license_worker'
+require_relative 'app_registration_worker'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Global helper methods for Cloudwise logging
+      # Respects DD_TRACE_DEBUG environment variable
+      class << self
+        # Check if debug logging is enabled
+        def debug_enabled?
+          @debug_enabled ||= ENV.fetch('DD_TRACE_DEBUG', 'false').downcase == 'true'
+        end
+
+        # Log debug message (only when DD_TRACE_DEBUG=true)
+        def log_debug(&block)
+          Datadog.logger.debug(&block) if debug_enabled?
+        end
+
+        # Log info message (only when DD_TRACE_DEBUG=true)
+        def log_info(&block)
+          Datadog.logger.info(&block) if debug_enabled?
+        end
+
+        # Log warning message (always shown)
+        def log_warn(&block)
+          Datadog.logger.warn(&block)
+        end
+
+        # Log error message (always shown)
+        def log_error(&block)
+          Datadog.logger.error(&block)
+        end
+      end
+
+      # 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
+
+        # 类级别的单例锁，确保全局只初始化一次
+        @initialization_mutex = Mutex.new
+        @initialization_started = false
+        @singleton_instance = nil
+
+        class << self
+          attr_accessor :initialization_mutex, :initialization_started, :singleton_instance
+        end
+
+        def initialize(settings:, logger:)
+          @logger = logger
+          @enabled = settings.cloudwise.enabled
+
+          return unless @enabled
+
+          # 使用工厂方法创建 Client，自动处理 SSL 配置
+          # AgentSettingsResolver 会根据以下优先级解析配置：
+          # 1. c.agent.use_ssl（代码配置）
+          # 2. DD_TRACE_AGENT_URL 环境变量的 scheme（https:// 或 http://）
+          # 3. 默认值（http）
+          @client = Client.from_settings(settings, logger: logger)
+
+          # 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
+          )
+        end
+
+        # Initialize Cloudwise asynchronously
+        # This will NOT block application startup
+        # Host ID generation runs in background and retries until success
+        # Cloudwise and Datadog functionality will NOT work until Host ID is ready
+        # Application can still serve requests normally
+        #
+        # @param block [Proc] Optional callback to run after Host ID is ready and Cloudwise workers are started
+        #                     This is used to initialize Datadog components after Host ID is ready
+        def initialize_async(&block)
+          return true unless @enabled
+
+          # 使用类级别的锁确保全局只初始化一次
+          cloudwise_already_started = false
+          self.class.initialization_mutex.synchronize do
+            if self.class.initialization_started
+              cloudwise_already_started = true
+              Cloudwise.log_debug { 'Cloudwise Component already initialized globally' }
+            else
+              # 检查是否有已存在的单例实例
+              if self.class.singleton_instance && self.class.singleton_instance.host_id_worker.started?
+                cloudwise_already_started = true
+                Cloudwise.log_debug { 'Initializing Datadog components for this Components instance...' }
+              else
+                self.class.initialization_started = true
+                self.class.singleton_instance = self
+              end
+            end
+          end
+
+          # 如果 Cloudwise 已经启动，只需要为这个新的 Components 实例初始化 Datadog 组件
+          if cloudwise_already_started
+            if block
+              block.call  # 立即初始化这个实例的 Datadog 组件
+            end
+            return true
+          end
+
+        # 立即初始化 Datadog 组件（不等待 Cloudwise 验证）
+        if block
+          Cloudwise.log_debug { 'Initializing Datadog components immediately...' }
+          block.call
+          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
+
+        # Start other Cloudwise workers in background
+        start_cloudwise_workers_when_ready
+
+        Cloudwise.log_debug { 'Cloudwise Component initialization started (async)' }
+
+          true
+        end
+
+        # Start background workers (async) - called after Host ID is ready
+        def start_background_workers
+          return unless @enabled
+
+          # Start Heartbeat Worker
+          Cloudwise.log_debug { 'Starting Heartbeat worker (60s interval)...' }
+          @heartbeat_worker.start
+
+          # Start Application Registration Worker
+          Cloudwise.log_debug { 'Starting Application registration worker (3 min interval)...' }
+          @app_registration_worker.start
+
+          # Start License Worker
+          Cloudwise.log_debug { 'Starting License verification worker (5 min interval)...' }
+          @license_worker.start
+        end
+
+        # Legacy async start method (for backward compatibility)
+        def start
+          return unless @enabled
+
+          Cloudwise.log_debug { 'Starting Cloudwise Component (Async)' }
+
+          # Step 1: Start Host ID Worker (will retry every 30s until success)
+          Cloudwise.log_debug { ' Step 1: Starting Host ID generation worker (30s retry)...' }
+          @host_id_worker.start
+
+          # Wait a bit to see if Host ID is generated immediately
+          sleep(1)
+
+          # Step 2: Start other workers
+          start_background_workers
+
+          Cloudwise.log_debug { 'Cloudwise Component started successfully' }
+        end
+
+        # 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' }
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        # Check if probe is active (not suspended)
+        def probe_active?
+          return true unless @enabled
+
+          probe_state.active?
+        end
+
+        # Get component status
+        def status
+          return { enabled: false } unless @enabled
+
+          probe_status = probe_state.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],
+            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?
+          }
+        end
+
+        private
+
+        # Start a background thread that waits for Host ID to be ready
+        # Then starts other Cloudwise workers
+        #
+        # New flow (Non-blocking Datadog initialization):
+        # 1. Datadog components initialize immediately (before this thread starts)
+        # 2. Wait for Host ID
+        # 3. Start Heartbeat worker
+        # 4. Start App Registration worker (non-blocking)
+        # 5. Start License worker
+        # 6. ProbeState controls whether data collection is active
+        def start_cloudwise_workers_when_ready
+          Thread.new do
+            Thread.current.name = 'Cloudwise-Initializer'
+
+            # ============================================================
+            # STEP 1: Wait for Host ID
+            # ============================================================
+            until host_id_worker.host_id_generated?
+              sleep(1)
+            end
+            Cloudwise.log_debug { 'Cloudwise: Host ID ready!' }
+
+            # ============================================================
+            # STEP 2: Start Heartbeat worker
+            # ============================================================
+            @heartbeat_worker.start
+
+            # Wait for first successful heartbeat
+            Cloudwise.log_debug { 'Cloudwise: Waiting for first successful heartbeat...' }
+            until probe_state.heartbeat_active?
+              sleep(1)
+            end
+
+            # ============================================================
+            # STEP 3: Start App Registration (non-blocking)
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise: Starting Application registration worker...' }
+            @app_registration_worker.start
+
+            # ============================================================
+            # STEP 4: Start License worker
+            # ============================================================
+            #
+            @license_worker.start
+
+            # Wait for first successful license validation
+            until probe_state.license_valid?
+              sleep(1)
+            end
+
+            # ============================================================
+            # All validations passed - Probe is now ACTIVE
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise: Data collection and reporting now enabled.' }
+          rescue => e
+            Cloudwise.log_error { "Cloudwise: 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
+        def generate_host_id_sync_infinite
+          retry_count = 0
+          retry_interval = 30 # seconds
+
+          loop do
+            retry_count += 1
+            Cloudwise.log_debug { "Cloudwise: Attempting Host ID generation (attempt #{retry_count})..." }
+
+            begin
+              result = client.generate_host_id
+
+              # Check if successful and code == 1000
+              if result[:success] && result[:code] == 1000 && client.account_id
+                # Success! Mark Host ID as ready
+                probe_state.mark_host_id_ready!
+
+                # Set environment variable
+                ENV['CLOUDWISE_ACCOUNT_ID'] = client.account_id
+
+                Cloudwise.log_debug { "Cloudwise: Host ID generated successfully on attempt #{retry_count}" }
+                Cloudwise.log_debug { "Cloudwise: account_id = #{client.account_id}" }
+
+                return # Success - exit the infinite loop
+              end
+
+              # Failed attempt - log and retry
+              error_msg = result[:error] || "code=#{result[:code]} (expected 1000)"
+              Cloudwise.log_warn { "Cloudwise: Host ID generation failed (attempt #{retry_count}): #{error_msg}" }
+              Cloudwise.log_warn { "Cloudwise: Retrying in #{retry_interval} seconds..." }
+
+              probe_state.mark_host_id_failed!
+
+            rescue => e
+              # Exception occurred - log and retry
+              Cloudwise.log_error { "Cloudwise: Host ID generation error (attempt #{retry_count}): #{e.class.name} #{e.message}" }
+              Cloudwise.log_error { "Cloudwise: Retrying in #{retry_interval} seconds..." }
+              probe_state.mark_host_id_failed!
+            end
+
+            # Wait before next retry
+            sleep(retry_interval)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# 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 every 30 seconds with retry mechanism
+      # 心跳失败 3 次后标记为无心跳，数据不采集
+      class HeartbeatWorker < Worker
+        include Workers::Polling
+
+        # 30 seconds interval
+        DEFAULT_INTERVAL = 30
+        # Retry interval: 30 seconds
+        RETRY_INTERVAL = 30
+        # Max retries: 3 times
+        MAX_RETRIES = 3
+        # 成功的状态码
+        CODE_SUCCESS = 1000
+
+        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
+          # Wait for Host ID to be generated
+          unless client.account_id
+            Cloudwise.log_debug { 'Cloudwise: Waiting for Host ID generation before heartbeat' }
+            return true
+          end
+
+          Cloudwise.log_debug { 'Cloudwise: Sending heartbeat' }
+
+          result = send_heartbeat_with_retry
+
+          process_heartbeat_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: 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 send_heartbeat_with_retry
+          retries = 0
+
+          loop do
+            result = client.heartbeat
+
+            # 接口请求成功
+            if result[:success]
+              return result
+            end
+
+            # 接口请求失败，重试逻辑
+            retries += 1
+            if retries < MAX_RETRIES
+              Cloudwise.log_warn { "Cloudwise: Heartbeat request failed (#{retries}/#{MAX_RETRIES}), retrying in #{RETRY_INTERVAL}s..." }
+              sleep(RETRY_INTERVAL)
+            else
+              Cloudwise.log_error { "Cloudwise: Heartbeat request failed after #{MAX_RETRIES} retries" }
+              # 立即标记为 inactive，不等下次 perform
+              Cloudwise.log_error { "Cloudwise: Data collection suspended due to heartbeat failure (immediate)" }
+              probe_state.mark_heartbeat_inactive!
+              @failure_count = 0  # 重置失败计数，避免重复处理
+              return result
+            end
+          end
+        end
+
+        def process_heartbeat_result(result)
+          # 接口请求失败（已在 send_heartbeat_with_retry 中处理过，这里跳过）
+          unless result[:success]
+            # 失败已经在 send_heartbeat_with_retry 中标记为 inactive
+            # 这里不再调用 handle_heartbeat_failure，避免重复累加
+            return
+          end
+
+          code = result[:code]
+
+          # 接口请求成功，但 code 不是 1000
+          if code != CODE_SUCCESS
+            Cloudwise.log_warn { "Cloudwise: Heartbeat returned code #{code} (expected #{CODE_SUCCESS})" }
+            Cloudwise.log_warn { "Cloudwise: Data collection suspended due to invalid heartbeat code" }
+            probe_state.mark_heartbeat_inactive!
+            @failure_count = 0  # 重置失败计数
+            return
+          end
+
+          # 成功且 code == 1000
+          Cloudwise.log_debug { 'Cloudwise: Heartbeat successful' }
+          probe_state.mark_heartbeat_active!
+          @failure_count = 0  # 重置失败计数
+        end
+
+        def handle_heartbeat_failure
+          @failure_count += 1
+
+          if @failure_count >= MAX_RETRIES
+            Cloudwise.log_error { "Cloudwise: Heartbeat failed #{@failure_count} times, marking as inactive" }
+            Cloudwise.log_error { "Cloudwise: Data collection suspended due to heartbeat failure" }
+            probe_state.mark_heartbeat_inactive!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that generates Host ID and retries every 30 seconds on failure
+      # Host ID 生成失败时，探针不采集数据
+      class HostIdWorker < Worker
+        include Workers::Polling
+
+        # 30 seconds interval for retry
+        RETRY_INTERVAL = 30
+        # 成功的状态码
+        CODE_SUCCESS = 1000
+
+        attr_reader :client
+
+        def initialize(client:, logger:, probe_state:, **options)
+          @client = client
+          @logger = logger
+          @probe_state = probe_state
+          @host_id_generated = 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 = RETRY_INTERVAL
+
+          self.enabled = options.fetch(:enabled, true)
+        end
+
+        def perform
+          # DEBUG: 添加详细日志来诊断重试问题
+          # 如果已经生成，则停止
+          if @host_id_generated
+            Cloudwise.log_info { "[WORKER DEBUG] Host ID already generated, stopping loop" }
+            stop_loop
+            return true
+          end
+
+          Cloudwise.log_debug { 'Cloudwise: Generating Host ID' }
+
+          result = client.generate_host_id
+
+          # 检查是否成功且 code == 1000
+          if result[:success] && result[:code] == CODE_SUCCESS && client.account_id
+            @host_id_generated = true
+            Cloudwise.log_debug { "Cloudwise: Host ID generated successfully, account_id: #{client.account_id}" }
+
+            # 标记 Host ID 就绪
+            probe_state.mark_host_id_ready!
+
+            # Stop this worker as we only need to generate once
+            stop_loop
+          else
+            # 失败或 code 不等于 1000，数据不采集
+            error_msg = result[:error] || "code=#{result[:code]} (expected #{CODE_SUCCESS})"
+            Cloudwise.log_warn { "Cloudwise: Host ID generation failed: #{error_msg}, will retry in #{RETRY_INTERVAL}s" }
+
+            # 确保状态标记为未就绪
+            probe_state.mark_host_id_failed!
+          end
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: Host ID worker error: #{e.class.name} #{e.message}" }
+          probe_state.mark_host_id_failed!
+          true # Continue running for retry
+        end
+
+        def host_id_generated?
+          @host_id_generated
+        end
+
+        private
+
+        attr_reader :logger, :probe_state
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that verifies license every 5 minutes with retry mechanism
+      # License 校验失败或接口失败 3 次，数据不采集
+      class LicenseWorker < Worker
+        include Workers::Polling
+
+        # 5 minutes interval (300 seconds)
+        DEFAULT_INTERVAL = 300
+        # Max retries: 3 times (累计失败次数)
+        MAX_RETRIES = 3
+        # 成功的状态码
+        CODE_SUCCESS = 1000
+
+        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
+          # Wait for Host ID to be generated
+          unless client.account_id
+            Cloudwise.log_debug { 'Cloudwise: Waiting for Host ID generation before license verification' }
+            return true
+          end
+
+          Cloudwise.log_debug { 'Cloudwise: Verifying license' }
+
+          result = client.verify_license
+
+          process_license_result(result)
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: License worker error: #{e.class.name} #{e.message}" }
+          handle_license_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_license_result(result)
+          # 接口请求失败
+          unless result[:success]
+            handle_license_failure
+            return
+          end
+
+          code = result[:code]
+
+          # License 校验成功 (code == 1000)
+          if code == CODE_SUCCESS
+            Cloudwise.log_debug { 'Cloudwise: License valid' }
+            probe_state.mark_license_valid!
+            @failure_count = 0  # 重置失败计数
+            return
+          end
+
+          # License 校验失败 (code != 1000)
+          Cloudwise.log_error { "Cloudwise: License verification failed with code #{code}" }
+          Cloudwise.log_error { "Cloudwise: Data collection suspended due to invalid license" }
+          probe_state.mark_license_invalid!
+          @failure_count = 0  # 重置失败计数（因为接口成功返回了）
+        end
+
+        def handle_license_failure
+          @failure_count += 1
+
+          Cloudwise.log_warn { "Cloudwise: License verification request failed (#{@failure_count}/#{MAX_RETRIES})" }
+
+          if @failure_count >= MAX_RETRIES
+            Cloudwise.log_error { "Cloudwise: License verification failed #{@failure_count} times, marking as invalid" }
+            probe_state.mark_license_invalid!
+          end
+        end
+      end
+    end
+  end
+end