daytona 0.196.0 → 0.197.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95de6205d02f5efc95082860ba7b1cc47d7aaa4a80add3b2799d7b62ece1d67c
-  data.tar.gz: 11c927bf961766c0eae71d6196a538688844913d06de0746497510b09137293e
+  metadata.gz: e838c81b167b038d7935b94479648df5ebecb486e34465986baaeed2da7a0a5c
+  data.tar.gz: 1dce18d22149936bf16af4beda9dcf52bb1de63a0b358c7e965f2dc663bd5933
 SHA512:
-  metadata.gz: 6f30debf54313e1bd30c6392b7ec2fd6c316306aad88eb3e1cd58fa0a51326f4036468c76fb2fe9388c41139aa40f0efecaa680d31eab6c16736f2f9dd9c250c
-  data.tar.gz: cf1ac1f0075f85966d2c9a00eb3c02d3c0e7080c8d7773fe9e5004c5e91bfd5e11670da7946ad15d5fcea13db6772d6c5918935d02f1f4a0cef61e010ae2f695
+  metadata.gz: e55a677df194a0dd60144888407f1186a03b26de14d9c3b4faf6d8611859c5d7ad059b73a1a3ce9cb41f22300c69b029139659817a27a7622e351073e00cb432
+  data.tar.gz: e62f6b6366d05fa9bd5343752064c1e50cdd4e0a93e101d7ec09791773e81feda4df1a856646c9961b09bdef2d96b2b7c7320afdca1e1f5189434f83556036a4

data/lib/daytona/common/daytona.rb

@@ -28,6 +28,11 @@ module Daytona
     # @return [Integer, nil] Auto-stop interval in minutes
     attr_accessor :auto_stop_interval
 
+    # @return [Integer, nil] Auto-pause interval in minutes (nil = server default: 60 for
+    #   non-ephemeral pause-supporting sandbox classes with auto-stop disabled; 0 = disabled).
+    #   Not allowed for ephemeral sandboxes
+    attr_accessor :auto_pause_interval
+
     # @return [Integer, nil] Auto-archive interval in minutes
     attr_accessor :auto_archive_interval
 
@@ -69,6 +74,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
@@ -87,6 +93,7 @@ module Daytona
       public: nil,
       timeout: nil,
       auto_stop_interval: nil,
+      auto_pause_interval: nil,
       auto_archive_interval: nil,
       auto_delete_interval: nil,
       volumes: nil,
@@ -104,6 +111,7 @@ module Daytona
       @public = public
       @timeout = timeout
       @auto_stop_interval = auto_stop_interval
+      @auto_pause_interval = auto_pause_interval
       @auto_archive_interval = auto_archive_interval
       @auto_delete_interval = auto_delete_interval
       @volumes = volumes
@@ -130,6 +138,7 @@ module Daytona
         public:,
         timeout:,
         auto_stop_interval:,
+        auto_pause_interval:,
         auto_archive_interval:,
         auto_delete_interval:,
         volumes:,
@@ -148,12 +157,15 @@ module Daytona
     #
     # @return [void]
     def handle_ephemeral_auto_delete_conflict
-      return unless ephemeral && auto_delete_interval && !auto_delete_interval.zero?
+      return unless ephemeral
+
+      if auto_delete_interval && !auto_delete_interval.zero?
+        warn(
+          "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
+          'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
+        )
+      end
 
-      warn(
-        "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
-        'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
-      )
       @auto_delete_interval = 0
     end
   end
@@ -178,6 +190,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
@@ -219,6 +232,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox

data/lib/daytona/common/pty.rb

@@ -7,6 +7,10 @@ require 'json'
 require 'observer'
 
 module Daytona
+  # Capability token advertised on PTY WebSocket connects so the daemon sends the
+  # "exited" control message; clients that don't send it only get the close frame.
+  PTY_EXIT_CONTROL_SUBPROTOCOL = 'X-Daytona-Pty-Exit-Control'
+
   class PtySize
     # @return [Integer] Number of terminal rows (height)
     attr_reader :rows
@@ -68,6 +72,7 @@ module Daytona
       @handle_kill = handle_kill
       @exit_code = nil
       @error = nil
+      @exited = false
       @logger = Sdk.logger
 
       @status = Status::INIT
@@ -77,21 +82,23 @@ module Daytona
     # Check if connected to the PTY session
     #
     # @return [Boolean] true if connected, false otherwise
-    def connected? = websocket.open?
+    # A PTY that has exited is not usable even while the socket briefly stays
+    # open before the close frame, so treat it as disconnected.
+    def connected? = websocket.open? && !@exited
 
     # Wait for the PTY connection to be established
     #
     # @param timeout [Float] Maximum time in seconds to wait for connection. Defaults to 10.0
     # @return [void]
     # @raise [Daytona::Sdk::Error] If connection timeout is exceeded
-    def wait_for_connection(timeout: DEFAULT_TIMEOUT)
-      return if status == Status::CONNECTED
+    def wait_for_connection(timeout: DEFAULT_TIMEOUT) # rubocop:disable Metrics/CyclomaticComplexity
+      return if status == Status::CONNECTED || @exited
 
       start_time = Time.now
 
-      sleep(SLEEP_INTERVAL) until status == Status::CONNECTED || (Time.now - start_time) > timeout
+      sleep(SLEEP_INTERVAL) until status == Status::CONNECTED || @exited || (Time.now - start_time) > timeout
 
-      raise Sdk::Error, 'PTY connection timeout' unless status == Status::CONNECTED
+      raise Sdk::Error, 'PTY connection timeout' unless status == Status::CONNECTED || @exited
     end
 
     # Send input to the PTY session
@@ -127,8 +134,9 @@ module Daytona
     #
     # @param on_data [Proc, nil] Optional callback to handle output data
     # @return [Daytona::PtyResult] Result containing exit code and error information
-    def wait(timeout: nil, &on_data)
+    def wait(timeout: nil, &on_data) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize
       timeout ||= Float::INFINITY
+      return PtyResult.new(exit_code:, error:) if @exited
       return unless status == Status::CONNECTED
 
       start_time = Time.now
@@ -239,11 +247,17 @@ module Daytona
 
     # @param data [WebSocket::Frame::Data]
     # @return [void]
-    def process_websocket_control_message(data) # rubocop:disable Metrics/MethodLength
+    def process_websocket_control_message(data) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       case data[:status]
       when WebSocketControlStatus::CONNECTED
         logger.debug('[control] connected')
         @status = Status::CONNECTED
+      when WebSocketControlStatus::EXITED
+        logger.debug("[control] exited: code=#{data[:exitCode]}")
+        @exit_code = data[:exitCode]
+        @error = data[:exitReason] if data[:exitReason]
+        @exited = true
+        @status = Status::CLOSED
       when WebSocketControlStatus::ERROR
         logger.debug("[control] error: #{error.inspect}")
         @status = Status::ERROR
@@ -302,6 +316,7 @@ module Daytona
     module WebSocketControlStatus
       ALL = [
         CONNECTED = 'connected',
+        EXITED = 'exited',
         ERROR = 'error'
       ].freeze
     end

data/lib/daytona/daytona.rb

@@ -48,6 +48,9 @@ module Daytona
       @api_client = build_api_client
       @sandbox_api = DaytonaApiClient::SandboxApi.new(api_client)
       @config_api = DaytonaApiClient::ConfigApi.new(api_client)
+      @analytics_api_url = nil
+      @analytics_api_url_fetched = false
+      @analytics_api_url_mutex = Mutex.new
       @volume = VolumeService.new(DaytonaApiClient::VolumesApi.new(api_client), otel_state:)
       @secret = SecretService.new(DaytonaApiClient::SecretApi.new(api_client), otel_state:)
       @object_storage_api = DaytonaApiClient::ObjectStorageApi.new(api_client)
@@ -68,7 +71,8 @@ module Daytona
     #
     # @param params [Daytona::CreateSandboxFromSnapshotParams, Daytona::CreateSandboxFromImageParams, Nil] Sandbox creation parameters
     # @return [Daytona::Sandbox] The created sandbox
-    # @raise [Daytona::Sdk::Error] If auto_stop_interval or auto_archive_interval is negative
+    # @raise [Daytona::Sdk::Error] If auto_stop_interval, auto_pause_interval, or auto_archive_interval is negative,
+    #   or if auto_stop_interval and auto_pause_interval are both non-zero
     def create(params = nil, on_snapshot_create_logs: nil)
       if params.nil?
         params = CreateSandboxFromSnapshotParams.new(language: CodeLanguage::PYTHON)
@@ -148,6 +152,18 @@ module Daytona
     # @return [Daytona::OtelState, nil]
     attr_reader :otel_state
 
+    # Resolves the deployment's Analytics API URL via /config, cached (including a nil
+    # result) for the client's lifetime. Errors are not cached, so failed lookups retry.
+    def analytics_api_url
+      @analytics_api_url_mutex.synchronize do
+        unless @analytics_api_url_fetched
+          @analytics_api_url = @config_api.config_controller_get_config.analytics_api_url
+          @analytics_api_url_fetched = true
+        end
+        @analytics_api_url
+      end
+    end
+
     # Fetches a single page of sandboxes. Each call produces one OTel span
     # ("Daytona.list_fetch_page") so that paginated iteration emits N spans
     # for N pages.
@@ -192,7 +208,8 @@ module Daytona
     # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s).
     # @param on_snapshot_create_logs [Proc]
     # @return [Daytona::Sandbox] The created sandbox
-    # @raise [Daytona::Sdk::Error] If auto_stop_interval or auto_archive_interval is negative
+    # @raise [Daytona::Sdk::Error] If auto_stop_interval, auto_pause_interval, or auto_archive_interval is negative,
+    #   or if auto_stop_interval and auto_pause_interval are both non-zero
     def _create(params, timeout: 60, on_snapshot_create_logs: nil)
       raise Sdk::Error, 'Timeout must be a non-negative number' if timeout.negative?
 
@@ -200,6 +217,17 @@ module Daytona
 
       raise Sdk::Error, 'auto_stop_interval must be a non-negative integer' if params.auto_stop_interval&.negative?
 
+      raise Sdk::Error, 'auto_pause_interval must be a non-negative integer' if params.auto_pause_interval&.negative?
+
+      if params.auto_stop_interval&.positive? && params.auto_pause_interval&.positive?
+        raise Sdk::Error,
+              'auto_stop_interval and auto_pause_interval are mutually exclusive. Set at most one of them to a non-zero value'
+      end
+
+      if params.auto_pause_interval&.positive? && params.auto_delete_interval&.zero?
+        raise Sdk::Error, 'Ephemeral sandboxes cannot have auto-pause enabled. Set auto_pause_interval to 0'
+      end
+
       if params.auto_archive_interval&.negative?
         raise Sdk::Error, 'auto_archive_interval must be a non-negative integer'
       end
@@ -214,6 +242,7 @@ module Daytona
         public: params.public,
         target: config.target,
         auto_stop_interval: params.auto_stop_interval,
+        auto_pause_interval: params.auto_pause_interval,
         auto_archive_interval: params.auto_archive_interval,
         auto_delete_interval: params.auto_delete_interval,
         volumes: params.volumes,
@@ -322,7 +351,8 @@ module Daytona
         sandbox_dto:,
         config:,
         sandbox_api:,
-        otel_state: @otel_state
+        otel_state: @otel_state,
+        analytics_api_url_provider: method(:analytics_api_url)
       )
     end
 

data/lib/daytona/process.rb

@@ -3,6 +3,8 @@
 
 # frozen_string_literal: true
 
+require 'base64'
+require 'json'
 require 'uri'
 
 module Daytona
@@ -410,19 +412,32 @@ module Daytona
     #   pty_handle.disconnect
     #
     # @raise [Daytona::Sdk::Error] If the PTY session creation fails or the session ID is already in use.
-    def create_pty_session(id:, cwd: nil, envs: nil, pty_size: nil) # rubocop:disable Metrics/MethodLength
-      response = toolbox_api.create_pty_session(
-        DaytonaToolboxApiClient::PtyCreateRequest.new(
-          id:,
-          cwd:,
-          envs:,
-          cols: pty_size&.cols,
-          rows: pty_size&.rows,
-          lazy_start: true
-        )
-      )
+    def create_pty_session(id:, cwd: nil, envs: nil, pty_size: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      cols = pty_size&.cols || 80
+      rows = pty_size&.rows || 24
+
+      preview_link = get_preview_link.call(WS_PORT)
+      url = URI.parse(preview_link.url)
+      url.scheme = url.scheme == 'https' ? 'wss' : 'ws'
+      url.path = '/process/pty/create-connect'
 
-      connect_pty_session(response.session_id)
+      params = { id:, cols:, rows: }
+      params[:cwd] = cwd if cwd
+      url.query = URI.encode_www_form(params)
+
+      headers = toolbox_api.api_client.default_headers.dup.merge(
+        'X-Daytona-Preview-Token' => preview_link.token
+      )
+      protocols = [headers['Sec-WebSocket-Protocol'], PTY_EXIT_CONTROL_SUBPROTOCOL].compact
+      protocols << "X-Daytona-Pty-Envs~#{Base64.urlsafe_encode64(envs.to_json, padding: false)}" if envs
+      headers['Sec-WebSocket-Protocol'] = protocols.join(', ')
+
+      PtyHandle.new(
+        WebSocket::Client::Simple.connect(url.to_s, headers:),
+        session_id: id,
+        handle_resize: ->(pty_size_arg) { resize_pty_session(id, pty_size_arg) },
+        handle_kill: -> { delete_pty_session(id) }
+      ).tap(&:wait_for_connection)
     end
 
     # Connects to an existing PTY session in the Sandbox.
@@ -448,13 +463,14 @@ module Daytona
       url.scheme = url.scheme == 'https' ? 'wss' : 'ws'
       url.path = "/process/pty/#{session_id}/connect"
 
+      headers = toolbox_api.api_client.default_headers.dup.merge(
+        'X-Daytona-Preview-Token' => preview_link.token
+      )
+      headers['Sec-WebSocket-Protocol'] =
+        [headers['Sec-WebSocket-Protocol'], PTY_EXIT_CONTROL_SUBPROTOCOL].compact.join(', ')
+
       handle = nil
-      WebSocket::Client::Simple.connect(
-        url.to_s,
-        headers: toolbox_api.api_client.default_headers.dup.merge(
-          'X-Daytona-Preview-Token' => preview_link.token
-        )
-      ) do |client|
+      WebSocket::Client::Simple.connect(url.to_s, headers:) do |client|
         handle = PtyHandle.new(
           client,
           session_id:,

data/lib/daytona/sandbox.rb

@@ -3,14 +3,33 @@
 
 # frozen_string_literal: true
 
+require 'time'
 require 'timeout'
 
 module Daytona
+  # A single point-in-time sample of historical Sandbox resource usage.
+  SandboxMetrics = Data.define(
+    :cpu_count, :cpu_used_pct, :disk_total, :disk_used,
+    :mem_total, :mem_used, :mem_cache, :timestamp
+  )
+
   class Sandbox # rubocop:disable Metrics/ClassLength
     include Instrumentation
 
     DEFAULT_TIMEOUT = 60
 
+    SANDBOX_METRIC_FIELD_BY_NAME = {
+      'daytona.sandbox.cpu.utilization' => :cpu_used_pct,
+      'daytona.sandbox.cpu.limit' => :cpu_count,
+      'daytona.sandbox.memory.usage' => :mem_used,
+      'daytona.sandbox.memory.limit' => :mem_total,
+      'daytona.sandbox.memory.cache' => :mem_cache,
+      'daytona.sandbox.filesystem.usage' => :disk_used,
+      'daytona.sandbox.filesystem.total' => :disk_total
+    }.freeze
+
+    SANDBOX_METRIC_NAMES = SANDBOX_METRIC_FIELD_BY_NAME.keys.freeze
+
     # @return [String] The ID of the sandbox
     attr_reader :id
 
@@ -79,6 +98,9 @@ module Daytona
     # @return [Float] Auto-stop interval in minutes (0 means disabled)
     attr_reader :auto_stop_interval
 
+    # @return [Float] Auto-pause interval in minutes (0 means disabled)
+    attr_reader :auto_pause_interval
+
     # @return [Float] Auto-archive interval in minutes
     attr_reader :auto_archive_interval
 
@@ -132,11 +154,12 @@ module Daytona
     # @params sandbox_api [DaytonaApiClient::SandboxApi]
     # @params sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @params otel_state [Daytona::OtelState, nil]
-    def initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil) # rubocop:disable Metrics/MethodLength
+    def initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil, analytics_api_url_provider: nil) # rubocop:disable Metrics/MethodLength
       process_response(sandbox_dto)
       @config = config
       @sandbox_api = sandbox_api
       @otel_state = otel_state
+      @analytics_api_url_provider = analytics_api_url_provider
 
       # Create toolbox API clients with dynamic configuration
       toolbox_api_config = build_toolbox_api_config
@@ -160,6 +183,7 @@ module Daytona
       interpreter_api = DaytonaToolboxApiClient::InterpreterApi.new(create_authenticated_client.call)
       info_api = DaytonaToolboxApiClient::InfoApi.new(create_authenticated_client.call)
       server_api = DaytonaToolboxApiClient::ServerApi.new(create_authenticated_client.call)
+      system_api = DaytonaToolboxApiClient::SystemApi.new(create_authenticated_client.call)
 
       @process = Process.new(
         sandbox_id: id,
@@ -180,6 +204,7 @@ module Daytona
       @lsp_api = lsp_api
       @info_api = info_api
       @server_api = server_api
+      @system_api = system_api
     end
 
     # Archives the sandbox, making it inactive and preserving its state. When sandboxes are
@@ -278,6 +303,21 @@ module Daytona
       @auto_stop_interval = interval
     end
 
+    # Sets the auto-pause interval for the Sandbox.
+    # The Sandbox will automatically pause after being idle (no new events) for the specified interval.
+    # Events include any state changes or interactions with the Sandbox through the SDK.
+    # Interactions using Sandbox Previews are not included.
+    #
+    # @param interval [Integer]
+    # @return [Integer]
+    # @raise [Daytona:Sdk::Error]
+    def auto_pause_interval=(interval)
+      raise Sdk::Error, 'Auto-pause interval must be a non-negative integer' if interval.negative?
+
+      sandbox_api.set_auto_pause_interval(id, interval)
+      @auto_pause_interval = interval
+    end
+
     # Creates an SSH access token for the sandbox.
     #
     # @param expires_in_minutes [Integer] TThe number of minutes the SSH access token will be valid for
@@ -338,6 +378,42 @@ module Daytona
       raise Sdk::Error, "Failed to update environment: #{e.message}"
     end
 
+    # Gets the most recent resource usage sample directly from the Sandbox daemon.
+    #
+    # Unlike #get_metrics, which returns aggregated historical samples, this returns the
+    # single current reading without going through the telemetry backend.
+    #
+    # @return [Daytona::SandboxMetrics]
+    #
+    # @example
+    #   m = sandbox.get_metrics_latest
+    #   puts "CPU used: #{m.cpu_used_pct}%"
+    def get_metrics_latest
+      sandbox_metrics_from_system_metrics(@system_api.get_system_metrics)
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get system metrics: #{e.message}"
+    end
+
+    # Gets historical time-series resource usage metrics for the Sandbox.
+    #
+    # @param start_time [Time, nil] Start of the range. Defaults to the Sandbox creation time.
+    # @param end_time [Time, nil] End of the range. Defaults to the current time.
+    # @return [Array<Daytona::SandboxMetrics>] Time-ordered usage samples.
+    #
+    # @example
+    #   sandbox.get_metrics.each { |m| puts "#{m.timestamp}: #{m.cpu_used_pct}%" }
+    def get_metrics(start_time = nil, end_time = nil)
+      from, to = metrics_range(start_time, end_time)
+      analytics_api_url = fetch_analytics_api_url
+      if analytics_api_url && !analytics_api_url.empty?
+        pivot_sandbox_metric_points(fetch_analytics_metrics(analytics_api_url, from, to))
+      else
+        pivot_sandbox_metrics(fetch_proxy_metrics(from, to))
+      end
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get sandbox metrics: #{e.message}"
+    end
+
     # Sets labels for the Sandbox.
     #
     # @param labels [Hash<String, String>]
@@ -568,7 +644,8 @@ module Daytona
           config:,
           sandbox_api:,
           code_toolbox:,
-          otel_state:
+          otel_state:,
+          analytics_api_url_provider: @analytics_api_url_provider
         )
         forked.send(:wait_for_states, operation: OPERATION_START,
                                       target_states: [DaytonaApiClient::SandboxState::STARTED])
@@ -609,9 +686,10 @@ module Daytona
       ) { wait_for_pause_complete }
     end
 
-    instrument :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_stop_interval=,
+    instrument :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_pause_interval=, :auto_stop_interval=,
                :update_network_settings, :update_secrets, :update_env,
-               :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :labels=,
+               :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :get_metrics, :get_metrics_latest,
+               :labels=,
                :preview_url, :create_signed_preview_url, :expire_signed_preview_url,
                :refresh, :refresh_activity, :revoke_ssh_access, :start, :recover, :stop,
                :create_lsp_server, :validate_ssh_access, :wait_for_sandbox_start,
@@ -621,6 +699,82 @@ module Daytona
 
     private
 
+    def pivot_sandbox_metrics(series)
+      buckets = {}
+      Array(series).each do |s|
+        Array(s.data_points).each { |point| add_metric_point(buckets, s.metric_name, point.timestamp, point.value) }
+      end
+      build_sandbox_metrics(buckets)
+    end
+
+    def add_metric_point(buckets, name, timestamp, value)
+      field = SANDBOX_METRIC_FIELD_BY_NAME[name]
+      return if field.nil? || timestamp.nil? || timestamp.to_s.empty? || value.nil?
+
+      (buckets[timestamp] ||= {})[field] = value
+    end
+
+    def build_sandbox_metrics(buckets)
+      buckets.keys.sort.map { |ts| build_sandbox_metric(ts, buckets[ts]) }
+    end
+
+    def build_sandbox_metric(timestamp, values)
+      SandboxMetrics.new(
+        cpu_count: values.fetch(:cpu_count, 0).to_i,
+        cpu_used_pct: values.fetch(:cpu_used_pct, 0).to_f,
+        disk_total: values.fetch(:disk_total, 0).to_i,
+        disk_used: values.fetch(:disk_used, 0).to_i,
+        mem_total: values.fetch(:mem_total, 0).to_i,
+        mem_used: values.fetch(:mem_used, 0).to_i,
+        mem_cache: values.fetch(:mem_cache, 0).to_i,
+        timestamp: Time.parse(timestamp)
+      )
+    end
+
+    def pivot_sandbox_metric_points(points)
+      buckets = {}
+      Array(points).each { |point| add_metric_point(buckets, point.metric_name, point.timestamp, point.value) }
+      build_sandbox_metrics(buckets)
+    end
+
+    def sandbox_metrics_from_system_metrics(system_metrics)
+      values = SANDBOX_METRIC_FIELD_BY_NAME.values.to_h { |field| [field, system_metrics.send(field)] }
+      build_sandbox_metric(system_metrics.timestamp || Time.now.iso8601, values)
+    end
+
+    def metrics_range(start_time, end_time)
+      to = end_time || Time.now
+      from = start_time || (created_at ? Time.parse(created_at) : to)
+      [from, to]
+    end
+
+    def fetch_analytics_api_url
+      return @analytics_api_url_provider.call if @analytics_api_url_provider
+
+      DaytonaApiClient::ConfigApi.new(sandbox_api.api_client).config_controller_get_config.analytics_api_url
+    end
+
+    def fetch_proxy_metrics(from, to)
+      sandbox_api.get_sandbox_metrics(id, from, to, metric_names: SANDBOX_METRIC_NAMES).series
+    end
+
+    def fetch_analytics_metrics(analytics_api_url, from, to)
+      analytics_telemetry_api(analytics_api_url).organization_organization_id_sandbox_sandbox_id_telemetry_metrics_get(
+        organization_id, id, from.utc.iso8601, to.utc.iso8601, metric_names: SANDBOX_METRIC_NAMES.join(',')
+      )
+    end
+
+    def analytics_telemetry_api(analytics_api_url) # rubocop:disable Metrics/AbcSize
+      uri = URI(analytics_api_url)
+      config = DaytonaAnalyticsApiClient::Configuration.new
+      config.scheme = uri.scheme
+      config.host = uri.authority
+      config.base_path = uri.path
+      config.api_key['Authorization'] = sandbox_api.api_client.config.access_token_getter&.call
+      config.api_key_prefix['Authorization'] = 'Bearer'
+      DaytonaAnalyticsApiClient::TelemetryApi.new(DaytonaAnalyticsApiClient::ApiClient.new(config))
+    end
+
     # @return [Daytona::OtelState, nil]
     attr_reader :otel_state
 
@@ -661,6 +815,7 @@ module Daytona
       @error_reason = sandbox_dto.error_reason
       @backup_state = sandbox_dto.backup_state
       @auto_stop_interval = sandbox_dto.auto_stop_interval
+      @auto_pause_interval = sandbox_dto.auto_pause_interval
       @auto_archive_interval = sandbox_dto.auto_archive_interval
       @auto_delete_interval = sandbox_dto.auto_delete_interval
       @created_at = sandbox_dto.created_at

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.196.0'
+    VERSION = '0.197.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -7,6 +7,7 @@ require 'logger'
 
 require 'daytona_api_client'
 require 'daytona_toolbox_api_client'
+require 'daytona_analytics_api_client'
 require 'toml'
 require 'websocket-client-simple'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.196.0
+  version: 0.197.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.196.0
+        version: 0.197.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.196.0
+        version: 0.197.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.196.0
+        version: 0.197.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.196.0
+        version: 0.197.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement