daytona 0.140.0 → 0.141.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97efbea0f339d4ec24eec1fe2a40ece74aa8f3eb0e74939d68e2fcd175f0c5e3
-  data.tar.gz: 9b97d704d4853538570dcb6e82c4ce82e3492526fe327e9b0ea9183f90279a0c
+  metadata.gz: 0c236b5ef310e5792aa5d1fcb33692ef2fda2a9c089e0ebe5dd0ee7e1a9b7a90
+  data.tar.gz: 2e0c388b5daa26e90b8eac72b578e0bcc8d5ce189b3cdfe128cb1a9d44da53e2
 SHA512:
-  metadata.gz: 2eb373cf9c9d84ea459df3c384265d674bba34b87671fef7be02cbf6964d907398685d9258a85742260c39cdd6755169c04155277657714dd44946d78bc89737
-  data.tar.gz: b728c4cd356eb6965b664cbd822283098ccd5e5dc5fc692826f6e743359973b2c64bde1c2ce447364774147f35bd30cef78134a24d509ff47e423c17e7515394
+  metadata.gz: 5e9dd352903ba61d1de768ab36c41ccfa94d0756b2cca41b11a30727d7b89a00a0add7a676d2c9fd663a364680f7f3ebeddd681c130d7a396db862d7242545e3
+  data.tar.gz: b0acf6153a896da1027e34c85e20d0433e5d741b5af700c4bd63e1a55f073e8d38fe34aafe6cf3df49a99795f8191ea1612f88d3538223f3d7aa5bd07c420325

data/lib/daytona/code_interpreter.rb

@@ -15,6 +15,8 @@ module Daytona
   # For other languages, use the `code_run` method from the `Process` interface,
   # or execute the appropriate command directly in the sandbox terminal.
   class CodeInterpreter
+    include Instrumentation
+
     WEBSOCKET_TIMEOUT_CODE = 4008
     WS_PORT = 2280
     private_constant :WS_PORT
@@ -22,10 +24,12 @@ module Daytona
     # @param sandbox_id [String]
     # @param toolbox_api [DaytonaToolboxApiClient::InterpreterApi]
     # @param get_preview_link [Proc]
-    def initialize(sandbox_id:, toolbox_api:, get_preview_link:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, get_preview_link:, otel_state: nil)
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
       @get_preview_link = get_preview_link
+      @otel_state = otel_state
     end
 
     # Execute Python code in the sandbox.
@@ -288,8 +292,14 @@ module Daytona
       raise Sdk::Error, "Failed to delete interpreter context: #{e.message}"
     end
 
+    instrument :run_code, :create_context, :list_contexts, :delete_context,
+               component: 'CodeInterpreter'
+
     private
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # @return [Hash<String, String>]
     def build_headers
       headers = {}

data/lib/daytona/computer_use.rb

@@ -3,6 +3,8 @@
 module Daytona
   class ComputerUse
     class Mouse
+      include Instrumentation
+
       # @return [String] The ID of the sandbox
       attr_reader :sandbox_id
 
@@ -11,9 +13,11 @@ module Daytona
 
       # @param sandbox_id [String] The ID of the sandbox
       # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
-      def initialize(sandbox_id:, toolbox_api:)
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
         @sandbox_id = sandbox_id
         @toolbox_api = toolbox_api
+        @otel_state = otel_state
       end
 
       # Gets the current mouse cursor position.
@@ -40,7 +44,7 @@ module Daytona
       # @example
       #   result = sandbox.computer_use.mouse.move(x: 100, y: 200)
       #   puts "Mouse moved to: #{result.x}, #{result.y}"
-      def move(x:, y:) # rubocop:disable Naming/MethodParameterName
+      def move(x:, y:)
         request = DaytonaToolboxApiClient::MouseMoveRequest.new(x:, y:)
         toolbox_api.move_mouse(request)
       rescue StandardError => e
@@ -65,7 +69,7 @@ module Daytona
       #
       #   # Right click
       #   right_click = sandbox.computer_use.mouse.click(x: 100, y: 200, button: 'right')
-      def click(x:, y:, button: 'left', double: false) # rubocop:disable Naming/MethodParameterName
+      def click(x:, y:, button: 'left', double: false)
         request = DaytonaToolboxApiClient::MouseClickRequest.new(x:, y:, button:, double:)
         toolbox_api.click(request)
       rescue StandardError => e
@@ -107,17 +111,26 @@ module Daytona
       #
       #   # Scroll down
       #   scroll_down = sandbox.computer_use.mouse.scroll(x: 100, y: 200, direction: 'down', amount: 5)
-      def scroll(x:, y:, direction:, amount: 1) # rubocop:disable Naming/MethodParameterName
+      def scroll(x:, y:, direction:, amount: 1)
         request = DaytonaToolboxApiClient::MouseScrollRequest.new(x:, y:, direction:, amount:)
         toolbox_api.scroll(request)
         true
       rescue StandardError => e
         raise Sdk::Error, "Failed to scroll mouse: #{e.message}"
       end
+
+      instrument :position, :move, :click, :drag, :scroll, component: 'Mouse'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
     end
 
     # Keyboard operations for computer use functionality.
     class Keyboard
+      include Instrumentation
+
       # @return [String] The ID of the sandbox
       attr_reader :sandbox_id
 
@@ -126,9 +139,11 @@ module Daytona
 
       # @param sandbox_id [String] The ID of the sandbox
       # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
-      def initialize(sandbox_id:, toolbox_api:)
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
         @sandbox_id = sandbox_id
         @toolbox_api = toolbox_api
+        @otel_state = otel_state
       end
 
       # Types the specified text.
@@ -194,10 +209,19 @@ module Daytona
       rescue StandardError => e
         raise Sdk::Error, "Failed to press hotkey: #{e.message}"
       end
+
+      instrument :type, :press, :hotkey, component: 'Keyboard'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
     end
 
     # Screenshot operations for computer use functionality.
     class Screenshot
+      include Instrumentation
+
       # @return [String] The ID of the sandbox
       attr_reader :sandbox_id
 
@@ -206,9 +230,11 @@ module Daytona
 
       # @param sandbox_id [String] The ID of the sandbox
       # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
-      def initialize(sandbox_id:, toolbox_api:)
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
         @sandbox_id = sandbox_id
         @toolbox_api = toolbox_api
+        @otel_state = otel_state
       end
 
       # Takes a screenshot of the entire screen.
@@ -292,7 +318,7 @@ module Daytona
       #     options: ScreenshotOptions.new(format: "webp", quality: 80, show_cursor: true)
       #   )
       #   puts "Compressed size: #{screenshot.size_bytes} bytes"
-      def take_compressed_region(region:, options: nil) # rubocop:disable Metrics/MethodLength
+      def take_compressed_region(region:, options: nil)
         options ||= ScreenshotOptions.new
         toolbox_api.take_compressed_region_screenshot(
           sandbox_id,
@@ -308,10 +334,20 @@ module Daytona
       rescue StandardError => e
         raise Sdk::Error, "Failed to take compressed region screenshot: #{e.message}"
       end
+
+      instrument :take_full_screen, :take_region, :take_compressed, :take_compressed_region,
+                 component: 'Screenshot'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
     end
 
     # Display operations for computer use functionality.
     class Display
+      include Instrumentation
+
       # @return [String] The ID of the sandbox
       attr_reader :sandbox_id
 
@@ -320,9 +356,11 @@ module Daytona
 
       # @param sandbox_id [String] The ID of the sandbox
       # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
-      def initialize(sandbox_id:, toolbox_api:)
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
         @sandbox_id = sandbox_id
         @toolbox_api = toolbox_api
+        @otel_state = otel_state
       end
 
       # Gets information about the displays.
@@ -359,6 +397,13 @@ module Daytona
       rescue StandardError => e
         raise Sdk::Error, "Failed to get windows: #{e.message}"
       end
+
+      instrument :info, :windows, component: 'Display'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
     end
 
     # Region coordinates for screenshot operations.
@@ -379,7 +424,7 @@ module Daytona
       # @param y [Integer] Y coordinate of the region
       # @param width [Integer] Width of the region
       # @param height [Integer] Height of the region
-      def initialize(x:, y:, width:, height:) # rubocop:disable Naming/MethodParameterName
+      def initialize(x:, y:, width:, height:)
         @x = x
         @y = y
         @width = width
@@ -415,6 +460,8 @@ module Daytona
 
     # Recording operations for computer use functionality.
     class Recording
+      include Instrumentation
+
       # @return [String] The ID of the sandbox
       attr_reader :sandbox_id
 
@@ -423,9 +470,11 @@ module Daytona
 
       # @param sandbox_id [String] The ID of the sandbox
       # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
-      def initialize(sandbox_id:, toolbox_api:)
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
         @sandbox_id = sandbox_id
         @toolbox_api = toolbox_api
+        @otel_state = otel_state
       end
 
       # Starts a new screen recording session.
@@ -568,8 +617,17 @@ module Daytona
         File.delete(local_path) if File.exist?(local_path)
         raise Sdk::Error, "Failed to download recording: #{e.message}"
       end
+
+      instrument :start, :stop, :list, :get, :delete, :download, component: 'Recording'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
     end
 
+    include Instrumentation
+
     # @return [String] The ID of the sandbox
     attr_reader :sandbox_id
 
@@ -595,14 +653,16 @@ module Daytona
     #
     # @param sandbox_id [String] The ID of the sandbox
     # @param toolbox_api [DaytonaApiClient::ToolboxApi] API client for sandbox operations
-    def initialize(sandbox_id:, toolbox_api:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
-      @mouse = Mouse.new(sandbox_id:, toolbox_api:)
-      @keyboard = Keyboard.new(sandbox_id:, toolbox_api:)
-      @screenshot = Screenshot.new(sandbox_id:, toolbox_api:)
-      @display = Display.new(sandbox_id:, toolbox_api:)
-      @recording = Recording.new(sandbox_id:, toolbox_api:)
+      @otel_state = otel_state
+      @mouse = Mouse.new(sandbox_id:, toolbox_api:, otel_state:)
+      @keyboard = Keyboard.new(sandbox_id:, toolbox_api:, otel_state:)
+      @screenshot = Screenshot.new(sandbox_id:, toolbox_api:, otel_state:)
+      @display = Display.new(sandbox_id:, toolbox_api:, otel_state:)
+      @recording = Recording.new(sandbox_id:, toolbox_api:, otel_state:)
     end
 
     # Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc).
@@ -706,5 +766,14 @@ module Daytona
     rescue StandardError => e
       raise Sdk::Error, "Failed to get process errors: #{e.message}"
     end
+
+    instrument :start, :stop, :status, :get_process_status, :restart_process,
+               :get_process_logs, :get_process_errors,
+               component: 'ComputerUse'
+
+    private
+
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
   end
 end

data/lib/daytona/config.rb

@@ -31,6 +31,11 @@ module Daytona
     # @return [String, nil] Daytona target
     attr_accessor :target
 
+    # Experimental configuration options
+    #
+    # @return [Hash, nil] Experimental configuration hash
+    attr_accessor :_experimental
+
     # Initializes a new Daytona::Config object.
     #
     # @param api_key [String, nil] Daytona API key. Defaults to ENV['DAYTONA_API_KEY'].
@@ -38,12 +43,14 @@ module Daytona
     # @param api_url [String, nil] Daytona API URL. Defaults to ENV['DAYTONA_API_URL'] or Daytona::Config::API_URL.
     # @param organization_id [String, nil] Daytona organization ID. Defaults to ENV['DAYTONA_ORGANIZATION_ID'].
     # @param target [String, nil] Daytona target. Defaults to ENV['DAYTONA_TARGET'].
-    def initialize(
+    # @param _experimental [Hash, nil] Experimental configuration options.
+    def initialize( # rubocop:disable Metrics/ParameterLists
       api_key: nil,
       jwt_token: nil,
       api_url: nil,
       organization_id: nil,
-      target: nil
+      target: nil,
+      _experimental: nil
     )
       # Load environment variables from .env and .env.local files
       # Files are loaded from the current working directory (where the code is executed)
@@ -54,6 +61,7 @@ module Daytona
       @api_url = api_url || ENV.fetch('DAYTONA_API_URL', API_URL)
       @target = target || ENV.fetch('DAYTONA_TARGET', nil)
       @organization_id = organization_id || ENV.fetch('DAYTONA_ORGANIZATION_ID', nil)
+      @_experimental = _experimental
     end
 
     private

data/lib/daytona/daytona.rb

@@ -4,7 +4,9 @@ require 'json'
 require 'uri'
 
 module Daytona
-  class Daytona # rubocop:disable Metrics/ClassLength
+  class Daytona
+    include Instrumentation
+
     # @return [Daytona::Config]
     attr_reader :config
 
@@ -27,20 +29,33 @@ module Daytona
     attr_reader :snapshot
 
     # @param config [Daytona::Config] Configuration options. Defaults to Daytona::Config.new
-    def initialize(config = Config.new) # rubocop:disable Metrics/AbcSize
+    def initialize(config = Config.new)
       @config = config
       ensure_access_token_defined
+
+      otel_enabled = config._experimental&.dig('otel_enabled') || ENV['DAYTONA_EXPERIMENTAL_OTEL_ENABLED'] == 'true'
+      @otel_state = (::Daytona.init_otel(Sdk::VERSION) if otel_enabled)
+
       @api_client = build_api_client
       @sandbox_api = DaytonaApiClient::SandboxApi.new(api_client)
       @config_api = DaytonaApiClient::ConfigApi.new(api_client)
-      @volume = VolumeService.new(DaytonaApiClient::VolumesApi.new(api_client))
+      @volume = VolumeService.new(DaytonaApiClient::VolumesApi.new(api_client), otel_state:)
       @object_storage_api = DaytonaApiClient::ObjectStorageApi.new(api_client)
       @snapshots_api = DaytonaApiClient::SnapshotsApi.new(api_client)
-      @snapshot = SnapshotService.new(snapshots_api:, object_storage_api:, default_region_id: config.target)
+      @snapshot = SnapshotService.new(snapshots_api:, object_storage_api:, default_region_id: config.target,
+                                      otel_state:)
       @proxy_toolbox_url_cache = {}
       @proxy_toolbox_url_mutex = Mutex.new
     end
 
+    # Shuts down OTel providers, flushing any pending telemetry data.
+    #
+    # @return [void]
+    def close
+      ::Daytona.shutdown_otel(@otel_state)
+      @otel_state = nil
+    end
+
     # Creates a sandbox with the specified parameters
     #
     # @param params [Daytona::CreateSandboxFromSnapshotParams, Daytona::CreateSandboxFromImageParams, Nil] Sandbox creation parameters
@@ -93,7 +108,7 @@ module Daytona
     # @param limit [Integer, Nil]
     # @return [Daytona::PaginatedResource]
     # @raise [Daytona::Sdk::Error]
-    def list(labels = {}, page: nil, limit: nil) # rubocop:disable Metrics/MethodLength
+    def list(labels = {}, page: nil, limit: nil)
       raise Sdk::Error, 'page must be positive integer' if page && page < 1
 
       raise Sdk::Error, 'limit must be positive integer' if limit && limit < 1
@@ -124,8 +139,13 @@ module Daytona
     # @return [void]
     def stop(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) = sandbox.stop(timeout)
 
+    instrument :create, :delete, :get, :find_one, :list, :start, :stop, component: 'Daytona'
+
     private
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # Creates a sandbox with the specified parameters
     #
     # @param params [Daytona::CreateSandboxFromSnapshotParams, Daytona::CreateSandboxFromImageParams] Sandbox creation parameters
@@ -133,7 +153,7 @@ module Daytona
     # @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
-    def _create(params, timeout: 60, on_snapshot_create_logs: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def _create(params, timeout: 60, on_snapshot_create_logs: nil)
       raise Sdk::Error, 'Timeout must be a non-negative number' if timeout.negative?
 
       start_time = Time.now
@@ -245,7 +265,8 @@ module Daytona
         config:,
         sandbox_api:,
         code_toolbox:,
-        get_proxy_toolbox_url: proc { |sandbox_id, region_id| proxy_toolbox_url(sandbox_id, region_id) }
+        get_proxy_toolbox_url: proc { |sandbox_id, region_id| proxy_toolbox_url(sandbox_id, region_id) },
+        otel_state: @otel_state
       )
     end
 

data/lib/daytona/file_system.rb

@@ -5,6 +5,8 @@ require 'fileutils'
 
 module Daytona
   class FileSystem
+    include Instrumentation
+
     # @return [String] The Sandbox ID
     attr_reader :sandbox_id
 
@@ -15,9 +17,11 @@ module Daytona
     #
     # @param sandbox_id [String] The Sandbox ID
     # @param toolbox_api [DaytonaToolboxApiClient::FileSystemApi] API client for Sandbox operations
-    def initialize(sandbox_id:, toolbox_api:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
+      @otel_state = otel_state
     end
 
     # Creates a new directory in the Sandbox at the specified path with the given
@@ -355,5 +359,15 @@ module Daytona
     rescue StandardError => e
       raise Sdk::Error, "Failed to set file permissions: #{e.message}"
     end
+
+    instrument :create_folder, :delete_file, :get_file_info, :list_files, :download_file,
+               :upload_file, :upload_files, :find_files, :search_files, :move_files,
+               :replace_in_files, :set_file_permissions,
+               component: 'FileSystem'
+
+    private
+
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
   end
 end

data/lib/daytona/git.rb

@@ -2,6 +2,8 @@
 
 module Daytona
   class Git
+    include Instrumentation
+
     # @return [String] The Sandbox ID
     attr_reader :sandbox_id
 
@@ -12,9 +14,11 @@ module Daytona
     #
     # @param sandbox_id [String] The Sandbox ID.
     # @param toolbox_api [DaytonaToolboxApiClient::GitApi] API client for Sandbox operations.
-    def initialize(sandbox_id:, toolbox_api:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
+      @otel_state = otel_state
     end
 
     # Stages the specified files for the next commit, similar to
@@ -276,5 +280,14 @@ module Daytona
     rescue StandardError => e
       raise Sdk::Error, "Failed to delete branch: #{e.message}"
     end
+
+    instrument :add, :branches, :clone, :commit, :push, :pull, :status,
+               :checkout_branch, :create_branch, :delete_branch,
+               component: 'Git'
+
+    private
+
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
   end
 end

data/lib/daytona/lsp_server.rb

@@ -2,6 +2,8 @@
 
 module Daytona
   class LspServer
+    include Instrumentation
+
     module Language
       ALL = [
         JAVASCRIPT = :javascript,
@@ -31,11 +33,13 @@ module Daytona
     # @param path_to_project [String]
     # @param toolbox_api [DaytonaToolboxApiClient::LspApi]
     # @param sandbox_id [String]
-    def initialize(language_id:, path_to_project:, toolbox_api:, sandbox_id:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(language_id:, path_to_project:, toolbox_api:, sandbox_id:, otel_state: nil)
       @language_id = language_id
       @path_to_project = path_to_project
       @toolbox_api = toolbox_api
       @sandbox_id = sandbox_id
+      @otel_state = otel_state
     end
 
     # Gets completion suggestions at a position in a file
@@ -114,8 +118,15 @@ module Daytona
       )
     end
 
+    instrument :completions, :did_close, :did_open, :document_symbols, :sandbox_symbols,
+               :start, :stop,
+               component: 'LspServer'
+
     private
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # Convert path to file uri.
     #
     # @param path [String]

data/lib/daytona/otel.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Daytona
+  # Holds OTel provider state for the SDK.
+  class OtelState
+    attr_reader :tracer_provider
+    attr_reader :meter_provider
+    attr_reader :tracer
+    attr_reader :meter
+
+    def initialize(tracer_provider:, meter_provider:, tracer:, meter:)
+      @tracer_provider = tracer_provider
+      @meter_provider = meter_provider
+      @tracer = tracer
+      @meter = meter
+      @histograms = {}
+      @histograms_mutex = Mutex.new
+    end
+
+    # Returns a cached histogram for the given metric name.
+    def histogram(name)
+      @histograms_mutex.synchronize do
+        @histograms[name] ||= meter.create_histogram(name, unit: 'ms')
+      end
+    end
+
+    def shutdown
+      tracer_provider.shutdown
+      meter_provider.shutdown
+    end
+  end
+
+  # Initializes OTel providers, sets globals, installs Typhoeus propagation.
+  # OTel gems are required lazily so they are never loaded when disabled.
+  #
+  # @param sdk_version [String]
+  # @return [OtelState]
+  def self.init_otel(sdk_version) # rubocop:disable Metrics/MethodLength
+    require 'opentelemetry-sdk'
+    require 'opentelemetry-metrics-sdk'
+    require 'opentelemetry-exporter-otlp'
+    require 'opentelemetry-exporter-otlp-metrics'
+
+    resource = OpenTelemetry::SDK::Resources::Resource.create(
+      'service.name' => 'daytona-ruby-sdk',
+      'service.version' => sdk_version
+    )
+
+    tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new(resource:)
+    tracer_provider.add_span_processor(
+      OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+        OpenTelemetry::Exporter::OTLP::Exporter.new
+      )
+    )
+    OpenTelemetry.tracer_provider = tracer_provider
+
+    meter_provider = OpenTelemetry::SDK::Metrics::MeterProvider.new(resource:)
+    meter_provider.add_metric_reader(
+      OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+        exporter: OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.new
+      )
+    )
+    OpenTelemetry.meter_provider = meter_provider
+
+    tracer = tracer_provider.tracer('daytona-ruby-sdk', sdk_version)
+    meter = meter_provider.meter('daytona-ruby-sdk')
+
+    # Install Typhoeus trace-context propagation
+    install_typhoeus_propagation
+
+    OtelState.new(tracer_provider:, meter_provider:, tracer:, meter:)
+  end
+
+  # Flushes and shuts down OTel providers.
+  def self.shutdown_otel(state)
+    state&.shutdown
+  end
+
+  # Wraps a block with OTel span creation and duration histogram recording.
+  # When otel_state is nil (OTel disabled), calls the block directly.
+  #
+  # @param otel_state [OtelState, nil]
+  # @param component [String]
+  # @param method_name [String]
+  # @return [Object] The block's return value
+  def self.with_instrumentation(otel_state, component, method_name, &block) # rubocop:disable Metrics/MethodLength
+    return block.call unless otel_state
+
+    span_name = "#{component}.#{method_name}"
+    metric_name = "#{to_snake_case(span_name)}_duration"
+    status = 'success'
+
+    otel_state.tracer.in_span(
+      span_name,
+      attributes: { 'component' => component, 'method' => method_name }
+    ) do |_span|
+      start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      begin
+        block.call
+      rescue StandardError => e
+        status = 'error'
+        raise e
+      ensure
+        duration_ms = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time) * 1000.0
+        otel_state.histogram(metric_name).record(
+          duration_ms,
+          attributes: { 'component' => component, 'method' => method_name, 'status' => status }
+        )
+      end
+    end
+  end
+
+  # Converts "ClassName.method_name" to "class_name_method_name".
+  def self.to_snake_case(str)
+    result = +''
+    str.each_char.with_index do |char, i|
+      if char == '.'
+        result << '_'
+      elsif char =~ /[A-Z]/ && i > 0 && str[i - 1] != '.'
+        result << '_' << char.downcase
+      else
+        result << char.downcase
+      end
+    end
+    result
+  end
+
+  # Installs Typhoeus.before callback for W3C trace-context propagation.
+  def self.install_typhoeus_propagation
+    return unless defined?(Typhoeus)
+
+    Typhoeus.before do |request|
+      headers = request.options[:headers] ||= {}
+      OpenTelemetry.propagation.inject(headers)
+      true
+    end
+  end
+
+  # Mixin that provides the `instrument` class macro for wrapping methods
+  # with OTel spans and metrics.
+  module Instrumentation
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Instruments the listed methods with OTel tracing/metrics.
+      # Must be called after all target methods are defined.
+      #
+      # @param method_names [Array<Symbol>] methods to instrument
+      # @param component [String] component name for span/metric attributes
+      def instrument(*method_names, component:) # rubocop:disable Metrics/MethodLength
+        method_names.each do |method_name|
+          original = instance_method(method_name)
+
+          # Detect original visibility
+          visibility = if private_method_defined?(method_name, false)
+                         :private
+                       elsif protected_method_defined?(method_name, false)
+                         :protected
+                       else
+                         :public
+                       end
+
+          define_method(method_name) do |*args, **kwargs, &blk|
+            ::Daytona.with_instrumentation(otel_state, component, method_name.to_s) do
+              original.bind_call(self, *args, **kwargs, &blk)
+            end
+          end
+
+          # Restore visibility
+          case visibility
+          when :private   then private method_name
+          when :protected then protected method_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daytona/process.rb

@@ -6,6 +6,8 @@ require 'uri'
 
 module Daytona
   class Process # rubocop:disable Metrics/ClassLength
+    include Instrumentation
+
     # @return [Daytona::SandboxPythonCodeToolbox,
     attr_reader :code_toolbox
 
@@ -24,11 +26,13 @@ module Daytona
     # @param sandbox_id [String] The ID of the Sandbox
     # @param toolbox_api [DaytonaToolboxApiClient::ProcessApi] API client for Sandbox operations
     # @param get_preview_link [Proc] Function to get preview link for a port
-    def initialize(code_toolbox:, sandbox_id:, toolbox_api:, get_preview_link:)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(code_toolbox:, sandbox_id:, toolbox_api:, get_preview_link:, otel_state: nil)
       @code_toolbox = code_toolbox
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
       @get_preview_link = get_preview_link
+      @otel_state = otel_state
     end
 
     # Execute a shell command in the Sandbox
@@ -448,8 +452,18 @@ module Daytona
       toolbox_api.get_pty_session(session_id)
     end
 
+    instrument :exec, :code_run, :create_session, :get_session, :get_session_command,
+               :execute_session_command, :get_session_command_logs, :get_session_command_logs_async,
+               :send_session_command_input, :list_sessions, :delete_session,
+               :create_pty_session, :connect_pty_session, :resize_pty_session,
+               :delete_pty_session, :list_pty_sessions, :get_pty_session_info,
+               component: 'Process'
+
     private
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # Parse the output of a command to extract ExecutionArtifacts
     #
     # @param lines [Array<String>] A list of lines of output from a command

data/lib/daytona/sandbox.rb

@@ -4,6 +4,8 @@ require 'timeout'
 
 module Daytona
   class Sandbox # rubocop:disable Metrics/ClassLength
+    include Instrumentation
+
     DEFAULT_TIMEOUT = 60
 
     # @return [String] The ID of the sandbox
@@ -116,12 +118,14 @@ module Daytona
     # @params config [Daytona::Config]
     # @params sandbox_api [DaytonaApiClient::SandboxApi]
     # @params sandbox_dto [DaytonaApiClient::Sandbox]
-    def initialize(code_toolbox:, sandbox_dto:, config:, sandbox_api:, get_proxy_toolbox_url:) # rubocop:disable Metrics/MethodLength
+    # @params otel_state [Daytona::OtelState, nil]
+    def initialize(code_toolbox:, sandbox_dto:, config:, sandbox_api:, get_proxy_toolbox_url:, otel_state: nil) # rubocop:disable Metrics/MethodLength
       process_response(sandbox_dto)
       @code_toolbox = code_toolbox
       @config = config
       @sandbox_api = sandbox_api
       @get_proxy_toolbox_url = get_proxy_toolbox_url
+      @otel_state = otel_state
 
       # Create toolbox API clients with dynamic configuration
       toolbox_api_config = build_toolbox_api_config
@@ -148,15 +152,17 @@ module Daytona
         sandbox_id: id,
         code_toolbox:,
         toolbox_api: process_api,
-        get_preview_link: proc { |port| preview_url(port) }
+        get_preview_link: proc { |port| preview_url(port) },
+        otel_state:
       )
-      @fs = FileSystem.new(sandbox_id: id, toolbox_api: fs_api)
-      @git = Git.new(sandbox_id: id, toolbox_api: git_api)
-      @computer_use = ComputerUse.new(sandbox_id: id, toolbox_api: computer_use_api)
+      @fs = FileSystem.new(sandbox_id: id, toolbox_api: fs_api, otel_state:)
+      @git = Git.new(sandbox_id: id, toolbox_api: git_api, otel_state:)
+      @computer_use = ComputerUse.new(sandbox_id: id, toolbox_api: computer_use_api, otel_state:)
       @code_interpreter = CodeInterpreter.new(
         sandbox_id: id,
         toolbox_api: interpreter_api,
-        get_preview_link: proc { |port| preview_url(port) }
+        get_preview_link: proc { |port| preview_url(port) },
+        otel_state:
       )
       @lsp_api = lsp_api
       @info_api = info_api
@@ -382,7 +388,7 @@ module Daytona
     #                      based on the sandbox working directory.
     # @return [Daytona::LspServer]
     def create_lsp_server(language_id:, path_to_project:)
-      LspServer.new(language_id:, path_to_project:, toolbox_api: @lsp_api, sandbox_id: id)
+      LspServer.new(language_id:, path_to_project:, toolbox_api: @lsp_api, sandbox_id: id, otel_state:)
     end
 
     #  Validates an SSH access token for the sandbox.
@@ -411,8 +417,19 @@ module Daytona
                                                                  DaytonaApiClient::SandboxState::DESTROYED])
     end
 
+    instrument :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_stop_interval=,
+               :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :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,
+               :wait_for_sandbox_stop,
+               component: 'Sandbox'
+
     private
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # Build toolbox API configuration with dynamic base URL from preview link
     # @return [DaytonaToolboxApiClient::Configuration]
     def build_toolbox_api_config

data/lib/daytona/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.140.0'
+    VERSION = '0.141.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -9,6 +9,7 @@ require 'websocket-client-simple'
 
 require_relative 'sdk/version'
 require_relative 'config'
+require_relative 'otel'
 require_relative 'common/charts'
 require_relative 'common/code_interpreter'
 require_relative 'common/code_language'

data/lib/daytona/snapshot_service.rb

@@ -4,15 +4,19 @@ require 'uri'
 
 module Daytona
   class SnapshotService
+    include Instrumentation
+
     SNAPSHOTS_FETCH_LIMIT = 200
 
     # @param snapshots_api [DaytonaApiClient::SnapshotsApi] The snapshots API client
     # @param object_storage_api [DaytonaApiClient::ObjectStorageApi] The object storage API client
     # @param default_region_id [String, nil] Default region ID for snapshot creation
-    def initialize(snapshots_api:, object_storage_api:, default_region_id: nil)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(snapshots_api:, object_storage_api:, default_region_id: nil, otel_state: nil)
       @snapshots_api = snapshots_api
       @object_storage_api = object_storage_api
       @default_region_id = default_region_id
+      @otel_state = otel_state
     end
 
     # List all Snapshots.
@@ -119,6 +123,8 @@ module Daytona
     # @return [Daytona::Snapshot]
     def activate(snapshot) = Snapshot.from_dto(snapshots_api.activate_snapshot(snapshot.id))
 
+    instrument :list, :delete, :get, :create, :activate, component: 'SnapshotService'
+
     # Processes the image context by uploading it to object storage
     #
     # @param image [Daytona::Image] The Image instance
@@ -156,6 +162,9 @@ module Daytona
     # @return [String, nil] Default region ID for snapshot creation
     attr_reader :default_region_id
 
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
+
     # Wait for snapshot to reach a terminal state (ACTIVE, ERROR, or BUILD_FAILED)
     # Optionally streams logs if on_logs callback is provided
     #

data/lib/daytona/volume_service.rb

@@ -2,11 +2,15 @@
 
 module Daytona
   class VolumeService
+    include Instrumentation
+
     # Service for managing Daytona Volumes. Can be used to list, get, create and delete Volumes.
     #
     # @param volumes_api [DaytonaApiClient::VolumesApi]
-    def initialize(volumes_api)
+    # @param otel_state [Daytona::OtelState, nil]
+    def initialize(volumes_api, otel_state: nil)
       @volumes_api = volumes_api
+      @otel_state = otel_state
     end
 
     # Create new Volume.
@@ -41,9 +45,14 @@ module Daytona
       volumes_api.list_volumes.map { |volume| Volume.new(volume) }
     end
 
+    instrument :create, :delete, :get, :list, component: 'VolumeService'
+
     private
 
     # @return [DaytonaApiClient::VolumesApi]
     attr_reader :volumes_api
+
+    # @return [Daytona::OtelState, nil]
+    attr_reader :otel_state
   end
 end

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.140.0
+  version: 0.141.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-10 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.29'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.29'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp-metrics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-metrics-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement
@@ -30,28 +86,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.140.0
+        version: 0.141.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.140.0
+        version: 0.141.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.140.0
+        version: 0.141.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.140.0
+        version: 0.141.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -131,6 +187,7 @@ files:
 - lib/daytona/git.rb
 - lib/daytona/lsp_server.rb
 - lib/daytona/object_storage.rb
+- lib/daytona/otel.rb
 - lib/daytona/process.rb
 - lib/daytona/sandbox.rb
 - lib/daytona/sdk.rb