cw-datadog 2.23.0.4 → 2.23.0.5

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

@@ -157,7 +157,7 @@ module Datadog
             imagePath: get_agent_path,
             ip: host_ip,
             agentId: generate_agent_id(host_ip),
-            timestamp: Time.now.to_i,
+            timestamp: get_adjusted_timestamp_seconds,
             routingKey: 'HeartBeat',
             classPath: '',
             isFirst: @is_first_heartbeat ? 1 : 0,
@@ -279,7 +279,7 @@ module Datadog
               sample: calculate_sample_rate,
               physical_ip: detect_container? ? get_host_real_ip : '',
               container_id: detect_container? ? get_container_id : '',
-              sys: ENV['CW_SYS'] || 'default',
+              sys: get_cloudwise_sys,
               env_tag: Datadog.configuration.env || 'default'
             }
           }
@@ -325,8 +325,61 @@ module Datadog
           post_docc("/api/ext/gaia/daemon/report/#{@agent_instance_id}", data)
         end
 
-        private
+        # 获取服务器时间戳接口
+        # @return [Hash] { success: true/false, server_timestamp: Integer (毫秒), offset_ms: Integer }
+        def fetch_server_timestamp
+          path = apply_api_prefix('/api/v70/timestamp')
+          uri = URI.join(base_url, path)
+
+          Cloudwise.log_debug { "Cloudwise: Fetching server timestamp from #{uri}" }
+
+          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::Get.new(uri.path)
+          request['User-Agent'] = "Datadog-Ruby-Agent/#{Datadog::VERSION::STRING}"
+          request['DD-Internal-Untraced-Request'] = '1'
+
+          # 记录请求前的本地时间
+          local_before = (Time.now.to_f * 1000).to_i
+
+          response = http.request(request)
+
+          # 记录请求后的本地时间
+          local_after = (Time.now.to_f * 1000).to_i
+
+          if response.code.to_i == 200
+            server_timestamp = response.body.to_s.strip.to_i
+
+            # 使用请求前后的中间时间作为本地参考时间
+            local_timestamp = (local_before + local_after) / 2
+
+            # 计算时间偏移（服务器时间 - 本地时间）
+            # 正值表示服务器时间比本地快，负值表示服务器时间比本地慢
+            offset_ms = server_timestamp - local_timestamp
+
+            Cloudwise.log_debug do
+              "Cloudwise: Server timestamp sync - server=#{server_timestamp}, local=#{local_timestamp}, offset=#{offset_ms}ms"
+            end
+
+            {
+              success: true,
+              server_timestamp: server_timestamp,
+              local_timestamp: local_timestamp,
+              offset_ms: offset_ms
+            }
+          else
+            Cloudwise.log_warn { "Cloudwise: path: #{path} Failed to fetch server timestamp: #{response.code}" }
+            { success: false, error: "HTTP #{response.code}" }
+          end
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: Error fetching server timestamp: #{e.message}" }
+          { success: false, error: e.message }
+        end
 
+        private
         def post(path, data)
           # 统一处理 API 路径前缀
           path = apply_api_prefix(path)
@@ -380,6 +433,31 @@ module Datadog
         end
 
 
+        # 获取校正后的秒级时间戳
+        # 如果启用了时间同步，会应用偏移量校正
+        # @return [Integer] 校正后的秒级时间戳
+        def get_adjusted_timestamp_seconds
+          local_time_s = Time.now.to_i
+          if defined?(TimeSyncWorker) && TimeSyncWorker.sync_enabled?
+            # offset_ms 是毫秒，转换为秒
+            local_time_s + (TimeSyncWorker.offset_ms / 1000)
+          else
+            local_time_s
+          end
+        end
+
+        # 获取校正后的毫秒级时间戳
+        # 如果启用了时间同步，会应用偏移量校正
+        # @return [Integer] 校正后的毫秒级时间戳
+        def get_adjusted_timestamp_ms
+          local_time_ms = (Time.now.to_f * 1000).to_i
+          if defined?(TimeSyncWorker) && TimeSyncWorker.sync_enabled?
+            local_time_ms + TimeSyncWorker.offset_ms
+          else
+            local_time_ms
+          end
+        end
+
         # 获取本机 IP 地址
         # 优先获取外网 IP（通过创建 UDP 连接，不实际发送数据）
         # 如果失败，尝试获取局域网 IP
@@ -623,7 +701,8 @@ module Datadog
             '/api/v1/agent/heartbeat',
             '/api/v1/agent/fuseHeart',
             '/v2/app/create',
-            '/v2/licence/verification'
+            '/v2/licence/verification',
+            '/api/v70/timestamp'
           ]
 
           # 检查是否是需要添加前缀的路径
@@ -704,6 +783,22 @@ module Datadog
         end
 
 
+        # 获取 Cloudwise sys 配置值
+        # 优先级: Datadog.configuration.cloudwise.sys > CW_SYS 环境变量 > 默认值 'default'
+        # @return [String] sys 值
+        def get_cloudwise_sys
+          # 优先从配置读取
+          if defined?(Datadog.configuration) &&
+             Datadog.configuration.respond_to?(:cloudwise) &&
+             Datadog.configuration.cloudwise.respond_to?(:sys)
+            sys = Datadog.configuration.cloudwise.sys
+            return sys if sys && !sys.empty? && sys != 'default'
+          end
+
+          # 其次从环境变量读取
+          ENV['CW_SYS'] || 'default'
+        end
+
         # Get current run user
         def get_run_user
           ENV['USER'] || ENV['USERNAME'] || 'cloudwise'

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

@@ -9,6 +9,7 @@ require_relative 'app_registration_worker'
 require_relative 'docc_registration_worker'
 require_relative 'docc_heartbeat_worker'
 require_relative 'docc_operation_worker'
+require_relative 'time_sync_worker'
 
 module Datadog
   module Core
@@ -46,7 +47,8 @@ module Datadog
       class Component
         attr_reader :client, :probe_state, :host_id_worker, :heartbeat_worker,
                     :license_worker, :app_registration_worker, :logger,
-                    :docc_registration_worker, :docc_heartbeat_worker, :docc_operation_worker
+                    :docc_registration_worker, :docc_heartbeat_worker, :docc_operation_worker,
+                    :time_sync_worker
 
         # 类级别的单例锁，确保全局只初始化一次
         @initialization_mutex = Mutex.new
@@ -185,6 +187,9 @@ module Datadog
         def stop
           return unless @enabled
 
+          # 停止时间同步 worker（两种模式都需要）
+          @time_sync_worker&.stop(true)
+
           if @client.use_integrated_mode?
             @docc_heartbeat_worker&.stop(true)
             @docc_registration_worker&.stop(true)
@@ -216,6 +221,13 @@ module Datadog
           return { enabled: false } unless @enabled
 
           probe_status = probe_state.status
+          # 获取时间同步状态
+          time_sync_status = if defined?(Datadog::Core::Cloudwise::TimeSyncWorker)
+                               Datadog::Core::Cloudwise::TimeSyncWorker.status
+                             else
+                               { enabled: false }
+                             end
+
           base_status = {
             enabled: true,
             integrated_mode: @client.use_integrated_mode?,
@@ -223,7 +235,10 @@ module Datadog
             probe_active: probe_state.active?,
             probe_suspended: probe_state.suspended?,
             license_valid: probe_status[:license_valid],
-            license_running: license_worker&.running?
+            license_running: license_worker&.running?,
+            time_sync_enabled: time_sync_status[:enabled],
+            time_sync_offset_ms: time_sync_status[:offset_ms],
+            time_sync_running: time_sync_worker&.running?
           }
 
           if @client.use_integrated_mode?
@@ -282,6 +297,13 @@ module Datadog
             probe_state: probe_state,
             interval: settings.cloudwise.license_check_interval
           )
+
+          # 5. Time Sync Worker (3 min interval, depends on License)
+          @time_sync_worker = TimeSyncWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state
+          )
         end
 
         # 初始化 DOCC 模式的 workers
@@ -315,6 +337,13 @@ module Datadog
             probe_state: probe_state,
             interval: settings.cloudwise.license_check_interval
           )
+
+          # 5. Time Sync Worker (3 min interval, depends on License)
+          @time_sync_worker = TimeSyncWorker.new(
+            client: client,
+            logger: logger,
+            probe_state: probe_state
+          )
         end
 
         # 检查实例是否已经启动
@@ -335,7 +364,8 @@ module Datadog
         # 3. Start Heartbeat worker
         # 4. Start App Registration worker (non-blocking)
         # 5. Start License worker
-        # 6. ProbeState controls whether data collection is active
+        # 6. Start Time Sync worker (3 min interval)
+        # 7. ProbeState controls whether data collection is active
         def start_cloudwise_workers_when_ready
           Thread.new do
             Thread.current.name = 'Cloudwise-Initializer'
@@ -368,7 +398,6 @@ module Datadog
             # ============================================================
             # STEP 4: Start License worker
             # ============================================================
-            #
             @license_worker.start
 
             # Wait for first successful license validation
@@ -376,6 +405,12 @@ module Datadog
               sleep(1)
             end
 
+            # ============================================================
+            # STEP 5: Start Time Sync worker (3 min interval)
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise: Starting Time Sync worker (3 min interval)...' }
+            @time_sync_worker.start
+
             # ============================================================
             # All validations passed - Probe is now ACTIVE
             # ============================================================
@@ -392,7 +427,8 @@ module Datadog
         # 2. 等待第一次心跳成功
         # 3. 启动 DOCC 注册 worker
         # 4. 启动 License worker
-        # 5. 启动 DOCC 操作 worker
+        # 5. 启动 Time Sync worker (3 min interval)
+        # 6. 启动 DOCC 操作 worker
         def start_docc_workers_when_ready
           Thread.new do
             Thread.current.name = 'Cloudwise-DOCC-Initializer'
@@ -400,11 +436,11 @@ module Datadog
             # ============================================================
             # STEP 1: Start DOCC Heartbeat worker
             # ============================================================
-            Cloudwise.log_debug { 'Cloudwise DOCC: Starting 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...' }
+            Cloudwise.log_debug { 'Cloudwise docc: Waiting for first successful heartbeat...' }
             until probe_state.docc_heartbeat_active?
               sleep(1)
             end
@@ -412,13 +448,13 @@ module Datadog
             # ============================================================
             # STEP 2: Start DOCC Registration worker
             # ============================================================
-            Cloudwise.log_debug { 'Cloudwise DOCC: Starting 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...' }
+            Cloudwise.log_debug { 'Cloudwise docc: Starting license worker...' }
             @license_worker.start
 
             # Wait for first successful license validation
@@ -427,17 +463,23 @@ module Datadog
             end
 
             # ============================================================
-            # STEP 4: Start DOCC Operation worker
+            # STEP 4: Start Time Sync worker (3 min interval)
+            # ============================================================
+            Cloudwise.log_debug { 'Cloudwise docc: Starting Time Sync worker (3 min interval)...' }
+            @time_sync_worker.start
+
+            # ============================================================
+            # STEP 5: Start DOCC Operation worker
             # ============================================================
-            Cloudwise.log_debug { 'Cloudwise DOCC: Starting 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.' }
+            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 { "Cloudwise docc: Error in background initializer: #{e.class.name} #{e.message}" }
             Cloudwise.log_error { e.backtrace.join("\n") }
           end
         end

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

@@ -170,10 +170,20 @@ module Datadog
               agent_id: 'rubyagent'
             },
             status: status,
-            timestamp: Time.now.to_i * 1000
+            timestamp: get_adjusted_timestamp_ms
           }
         end
 
+        # 获取校正后的毫秒时间戳
+        def get_adjusted_timestamp_ms
+          local_time_ms = (Time.now.to_f * 1000).to_i
+          if defined?(TimeSyncWorker) && TimeSyncWorker.sync_enabled?
+            local_time_ms + TimeSyncWorker.offset_ms
+          else
+            local_time_ms
+          end
+        end
+
         # 批量上报操作结果
         def report_operation_results(results)
           result = client.docc_report_operation(results)

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

@@ -159,9 +159,16 @@ module Datadog
         end
 
         # 仅在状态发生变化时上报熔断状态
+        # 注意：融合模式（use_integrated_mode）下不进行上报
         # @param fuse_state [Integer] 熔断状态: 0-正常, 1-熔断
         # @param fuse_describe [Integer, nil] 熔断描述: 7/8/9/10，正常状态时为nil
         def report_fuse_state_if_changed(fuse_state, fuse_describe)
+          # 融合模式下不上报熔断状态
+          if client.use_integrated_mode?
+            Cloudwise.log_debug { 'Cloudwise: Integrated mode enabled, skip fuse state reporting' }
+            return
+          end
+
           # 检查状态是否发生变化
           if @last_fuse_state == fuse_state && @last_fuse_describe == fuse_describe
             Cloudwise.log_debug { "Cloudwise: Fuse state unchanged (state: #{fuse_state}, describe: #{fuse_describe}), skip reporting" }

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative '../worker'
+require_relative '../workers/async'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Cloudwise
+      # Worker that synchronizes time with server every 3 minutes
+      # 时间同步 Worker，每 3 分钟执行一次
+      # 整合了时间偏移量管理和定时同步功能
+      class TimeSyncWorker < Worker
+        include Workers::Polling
+
+        # 3 minutes interval (180 seconds)
+        DEFAULT_INTERVAL = 180
+
+        # 最大偏移量阈值（毫秒）- 超过此值才进行校正
+        # 小于 100ms 的偏移可以忽略
+        OFFSET_THRESHOLD_MS = 100
+
+        # 类级别的时间偏移量状态（全局共享）
+        @offset_ms = 0
+        @sync_enabled = false
+        @last_sync_time = nil
+        @state_mutex = Mutex.new
+
+        class << self
+          attr_reader :state_mutex
+
+          # 获取当前时间偏移量（毫秒）
+          # @return [Integer] 时间偏移量，正值表示服务器时间比本地快
+          def offset_ms
+            @offset_ms ||= 0
+          end
+
+          # 设置时间偏移量
+          # @param value [Integer] 偏移量（毫秒）
+          def offset_ms=(value)
+            @offset_ms = value.to_i
+          end
+
+          # 获取时间偏移量（纳秒）
+          # @return [Integer] 时间偏移量（纳秒）
+          def offset_ns
+            offset_ms * 1_000_000
+          end
+
+          # 检查是否启用时间同步
+          # @return [Boolean]
+          def sync_enabled?
+            @sync_enabled ||= false
+          end
+
+          # 启用时间同步
+          def enable_sync!
+            @sync_enabled = true
+          end
+
+          # 禁用时间同步
+          def disable_sync!
+            @sync_enabled = false
+            @offset_ms = 0
+          end
+
+          # 上次同步时间
+          # @return [Integer, nil] 毫秒时间戳
+          def last_sync_time
+            @last_sync_time
+          end
+
+          # 设置上次同步时间
+          def last_sync_time=(value)
+            @last_sync_time = value
+          end
+
+          # 校正时间戳（纳秒）
+          # 将本地时间戳转换为服务器时间戳
+          # @param local_time_ns [Integer] 本地时间戳（纳秒）
+          # @return [Integer] 校正后的时间戳（纳秒）
+          def adjust_timestamp_ns(local_time_ns)
+            return local_time_ns unless sync_enabled?
+            return local_time_ns if offset_ms.abs < OFFSET_THRESHOLD_MS
+
+            local_time_ns + offset_ns
+          end
+
+          # 校正 Time 对象
+          # @param time [Time] 本地时间
+          # @return [Time] 校正后的时间
+          def adjust_time(time)
+            return time unless sync_enabled?
+            return time if offset_ms.abs < OFFSET_THRESHOLD_MS
+
+            time + (offset_ms / 1000.0)
+          end
+
+          # 重置状态（用于测试）
+          def reset!
+            @offset_ms = 0
+            @sync_enabled = false
+            @last_sync_time = nil
+          end
+
+          # 获取同步状态信息
+          # @return [Hash]
+          def status
+            {
+              enabled: sync_enabled?,
+              offset_ms: offset_ms,
+              offset_ns: offset_ns,
+              last_sync_time: last_sync_time
+            }
+          end
+        end
+
+        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
+          # 只有在 License 校验通过后才执行时间同步
+          unless probe_state.license_valid?
+            Cloudwise.log_debug { 'Cloudwise: Waiting for license validation before time sync' }
+            return true
+          end
+
+          Cloudwise.log_debug { 'Cloudwise: Performing server time synchronization' }
+
+          if sync_time!
+            Cloudwise.log_debug { "Cloudwise: Time sync completed, offset=#{self.class.offset_ms}ms" }
+          else
+            Cloudwise.log_warn { 'Cloudwise: Time sync failed' }
+          end
+
+          true
+        rescue => e
+          Cloudwise.log_error { "Cloudwise: Time sync 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
+
+        # 执行时间同步
+        # @return [Boolean] 是否同步成功
+        def sync_time!
+          return false unless client
+
+          result = client.fetch_server_timestamp
+          if result[:success]
+            self.class.state_mutex.synchronize do
+              self.class.offset_ms = result[:offset_ms]
+              self.class.last_sync_time = (Time.now.to_f * 1000).to_i
+              self.class.enable_sync!
+            end
+
+            Cloudwise.log_info do
+              "Cloudwise TimeSync: Synchronized with server, offset=#{self.class.offset_ms}ms"
+            end
+
+            true
+          else
+            Cloudwise.log_warn do
+              "Cloudwise TimeSync: Failed to sync - #{result[:error]}"
+            end
+            false
+          end
+        rescue => e
+          Cloudwise.log_error do
+            "Cloudwise TimeSync: Error during sync - #{e.message}"
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/configuration/settings.rb

@@ -12,6 +12,7 @@ require_relative '../remote/ext'
 require_relative '../../profiling/ext'
 
 require_relative '../../tracing/configuration/settings'
+require_relative '../../opentelemetry/configuration/settings'
 
 module Datadog
   module Core
@@ -1095,6 +1096,15 @@ module Datadog
             o.default 180
           end
         end
+        # Enable experimental process tags propagation such that payloads like spans contain the process tag.
+        #
+        # @default `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable, otherwise `false`
+        # @return [Boolean]
+        option :experimental_propagate_process_tags_enabled do |o|
+          o.env 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
+          o.default false
+          o.type :bool
+        end
 
         # Tracer specific configuration starting with APM (e.g. DD_APM_TRACING_ENABLED).
         # @public_api
@@ -1123,6 +1133,8 @@ module Datadog
         # TODO: Tracing should manage its own settings.
         #       Keep this extension here for now to keep things working.
         extend Datadog::Tracing::Configuration::Settings
+
+        extend Datadog::OpenTelemetry::Configuration::Settings
       end
       # standard:enable Metrics/BlockLength
     end

data/lib/datadog/core/configuration/supported_configurations.rb

@@ -51,6 +51,7 @@ module Datadog
          "DD_ERROR_TRACKING_HANDLED_ERRORS" => {version: ["A"]},
          "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE" => {version: ["A"]},
          "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED" => {version: ["A"]},
+         "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED" => {version: ["A"]},
          "DD_GIT_COMMIT_SHA" => {version: ["A"]},
          "DD_GIT_REPOSITORY_URL" => {version: ["A"]},
          "DD_HEALTH_METRICS_ENABLED" => {version: ["A"]},
@@ -63,6 +64,7 @@ module Datadog
          "DD_INTEGRATION_SERVICE" => {version: ["A"]},
          "DD_LOGS_INJECTION" => {version: ["A"]},
          "DD_METRIC_AGENT_PORT" => {version: ["A"]},
+         "DD_METRICS_OTEL_ENABLED" => {version: ["A"]},
          "DD_PROFILING_ALLOCATION_ENABLED" => {version: ["A"]},
          "DD_PROFILING_DIR_INTERRUPTION_WORKAROUND_ENABLED" => {version: ["A"]},
          "DD_PROFILING_ENABLED" => {version: ["A"]},
@@ -320,6 +322,18 @@ module Datadog
          "DD_TRACE_WATERDROP_ENABLED" => {version: ["A"]},
          "DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH" => {version: ["A"]},
          "DD_VERSION" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_ENDPOINT" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_HEADERS" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_METRICS_HEADERS" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_PROTOCOL" => {version: ["A"]},
+         "OTEL_EXPORTER_OTLP_TIMEOUT" => {version: ["A"]},
+         "OTEL_METRIC_EXPORT_INTERVAL" => {version: ["A"]},
+         "OTEL_METRIC_EXPORT_TIMEOUT" => {version: ["A"]},
+         "OTEL_METRICS_EXPORTER" => {version: ["A"]},
          "OTEL_TRACES_SAMPLER_ARG" => {version: ["A"]}}.freeze
 
       ALIASES =

data/lib/datadog/core/environment/ext.rb

@@ -33,8 +33,14 @@ module Datadog
         LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}"
         LANG_PLATFORM = RUBY_PLATFORM
         LANG_VERSION = RUBY_VERSION
+        PROCESS_TYPE = 'script' # Out of the options [jar, script, class, executable], we consider Ruby to always be a script
         RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
         TAG_ENV = 'env'
+        TAG_ENTRYPOINT_BASEDIR = "entrypoint.basedir"
+        TAG_ENTRYPOINT_NAME = "entrypoint.name"
+        TAG_ENTRYPOINT_WORKDIR = "entrypoint.workdir"
+        TAG_ENTRYPOINT_TYPE = "entrypoint.type"
+        TAG_PROCESS_TAGS = "_dd.tags.process"
         TAG_SERVICE = 'service'
         TAG_VERSION = 'version'