javonet-ruby-sdk 2.5.20 → 2.6.0

data/lib/javonet-ruby-sdk/core/handler/resolve_instance_handler.rb

@@ -1,5 +1,7 @@
 require_relative '../reference_cache/references_cache'
 require_relative 'abstract_command_handler'
+require_relative '../../utils/runtime_name'
+require_relative '../../utils/command'
 
 class ResolveInstanceHandler < AbstractCommandHandler
   def initialize
@@ -7,7 +9,7 @@ class ResolveInstanceHandler < AbstractCommandHandler
   end
 
   def process(command)
-    return resolve_reference(command)
+    resolve_reference(command)
   end
 
   def resolve_reference(command)
@@ -15,10 +17,13 @@ class ResolveInstanceHandler < AbstractCommandHandler
       raise ArgumentError.new "Resolve Instance parameters mismatch"
     end
     begin
-      references_cache = ReferencesCache.instance
-      return references_cache.resolve_reference(command.payload[0])
+      if command.runtime_name == RuntimeName::RUBY
+        return ReferencesCache.instance.resolve_reference(command.payload[0])
+      else
+        return new Command(command.runtime_name, CommandType::REFERENCE, command.payload[0])
+      end
     rescue Exception => ex
       return ex
     end
   end
-end
+end

data/lib/javonet-ruby-sdk/core/interpreter/interpreter.rb

@@ -10,6 +10,9 @@ class Interpreter
     if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
+    elsif connection_type == ConnectionType::WEB_SOCKET
+      require_relative '../web_socket_client/web_socket_client'
+      response_byte_array = WebSocketClient.send_message(connection_data.hostname, message_byte_array)
     else
       require_relative '../transmitter/transmitter'
       response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)

data/lib/javonet-ruby-sdk/core/receiver/receiver.rb

@@ -1,17 +1,33 @@
 require_relative '../interpreter/interpreter'
 require_relative '../../utils/runtime_logger'
 require_relative '../protocol/command_serializer'
+require_relative '../../utils/command'
 
 class Receiver
 
   def initialize
-    #RuntimeLogger.print_runtime_info
+    puts get_runtime_info
   end
 
   def send_command(message_array, message_array_len)
-    CommandSerializer.new.serialize(Interpreter.new.process(message_array))
+    begin
+      CommandSerializer.new.serialize(Interpreter.new.process(message_array))
+    rescue Exception => e
+      message = "Error occurred in Javonet Ruby Core: #{e.message}"
+      puts message
+      exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
+      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
+      exception_command = exception_command.add_arg_to_payload(Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, ["Ruby Core Error", "Ruby Core Error"]).to_string)
+      exception_command = exception_command.add_arg_to_payload("Ruby Core Error")
+      exception_command = exception_command.add_arg_to_payload(e.message)
+      exception_command = exception_command.add_arg_to_payload("Receiver")
+      exception_command = exception_command.add_arg_to_payload("send_command")
+      exception_command = exception_command.add_arg_to_payload("undefined")
+      exception_command = exception_command.add_arg_to_payload(__FILE__)
+      CommandSerializer.new.serialize(exception_command)
+    end
   end
-  
+
   def heart_beat(message_array, message_array_len)
     [49,48]
   end
@@ -20,3 +36,4 @@ class Receiver
     RuntimeLogger.get_runtime_info(true)
   end
 end
+

data/lib/javonet-ruby-sdk/core/web_socket_client/web_socket_client.rb

@@ -0,0 +1,108 @@
+require 'websocket'
+require 'uri'
+
+class WebSocketClient
+  def initialize(url)
+    @uri = URI.parse(url)
+    raise "Only ws:// or wss:// URLs are supported" unless %w[ws wss].include?(@uri.scheme)
+
+    @host = @uri.host
+    @port = @uri.port || default_port
+    @path = @uri.path.empty? ? '/' : @uri.path
+    @path += "?#{@uri.query}" if @uri.query
+
+    @socket = open_socket
+    @handshake = WebSocket::Handshake::Client.new(
+      url: url
+    )
+
+    perform_handshake
+  end
+
+  def send_message(message)
+    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, data: message.pack("C*"), type: :binary)
+    @socket.write(frame.to_s)
+  end
+
+  def receive_message(timeout: 5)
+    buffer = ''
+    start_time = Time.now
+
+    while Time.now - start_time < timeout
+      if IO.select([@socket], nil, nil, 0.1)
+        chunk = @socket.read_nonblock(1024, exception: false)
+        break if chunk.nil?
+
+        buffer << chunk
+        frame = WebSocket::Frame::Incoming::Client.new(version: @handshake.version)
+        frame << buffer
+        data = frame.next
+        return data.data.bytes if data
+      end
+    end
+
+    nil
+  end
+
+  def self.add_or_get_client(url)
+    @@clients ||= {}
+    client = @@clients[url]
+    if client.nil? || !client.open?
+      client&.close
+      client = new(url)
+      @@clients[url] = client
+    end
+    client
+  end
+
+  def self.send_message(url, message)
+    client = add_or_get_client(url)
+    client.send_message(message)
+    client.receive_message
+  end
+
+  def open?
+    !@socket.closed?
+  end
+
+  def close
+    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, type: :close)
+    @socket.write(frame.to_s)
+    @socket.close
+  end
+
+  private
+
+  def default_port
+    @uri.scheme == 'wss' ? 443 : 80
+  end
+
+  def open_socket
+    tcp = TCPSocket.new(@host, @port)
+
+    if @uri.scheme == 'wss'
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp, ssl_context)
+      ssl.sync_close = true
+      ssl.hostname = @host
+      ssl.connect
+      ssl
+    else
+      tcp
+    end
+  end
+
+  def perform_handshake
+    @socket.write(@handshake.to_s)
+
+    until @handshake.finished?
+      line = @socket.gets
+      break if line.nil?
+
+      @handshake << line
+    end
+
+    raise "WebSocket handshake failed!" unless @handshake.valid?
+  end
+end

data/lib/javonet-ruby-sdk/sdk/config_runtime_factory.rb

@@ -94,6 +94,9 @@ class ConfigRuntimeFactory < AbstractConfigRuntimeFactory
       conn_data = TcpConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name),
                                         jfr.get_channel_port(RuntimeNameHandler.get_name(runtime), config_name))
       rtm_ctx =  RuntimeContext.get_instance(runtime, ConnectionType::TCP, conn_data)
+    elsif conn_type == "webSocket"
+      conn_data = WsConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name))
+      rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::WEB_SOCKET, conn_data)
     elsif conn_type == "inMemory"
       rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::IN_MEMORY, nil)
     else
@@ -118,4 +121,4 @@ class ConfigRuntimeFactory < AbstractConfigRuntimeFactory
       end
     end
   end
-end
+end

data/lib/javonet-ruby-sdk/sdk/javonet.rb

@@ -1,7 +1,6 @@
 require_relative './runtime_factory'
 require_relative './config_runtime_factory'
 require_relative './../utils/connection_type'
-require_relative './../utils/tcp_connection_data'
 require_relative './../utils/runtime_logger'
 require_relative './../core/transmitter/transmitter'
 require_relative './tools/sdk_message_helper'
@@ -30,6 +29,14 @@ class Javonet
     RuntimeFactory.new(ConnectionType::TCP, tcp_connection_data)
   end
 
+  # Initializes Javonet with a WebSocket connection to a remote machine.
+  # @param ws_connection_data [WsConnectionData] The address of the remote machine.
+  # @return [RuntimeFactory] A RuntimeFactory instance configured for a WebSocket connection.
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/websocket-channel article on Javonet Guides}
+  def self.web_socket(ws_connection_data)
+    RuntimeFactory.new(ConnectionType::WEB_SOCKET, ws_connection_data)
+  end
+
   # Initializes Javonet with a custom configuration file.
   # @param path [String] Path to a configuration file.
   # @return [ConfigRuntimeFactory] A ConfigRuntimeFactory instance configured with configuration data

data/lib/javonet-ruby-sdk/sdk/runtime_context.rb

@@ -2,6 +2,7 @@ require_relative './internal/abstract_runtime_context'
 require_relative './invocation_context'
 require_relative './../utils/connection_type'
 require_relative './../utils/tcp_connection_data'
+require_relative './../utils/ws_connection_data'
 require_relative './../core/interpreter/interpreter'
 
 # Represents a single context which allows interaction with a selected technology.
@@ -15,6 +16,7 @@ require_relative './../core/interpreter/interpreter'
 class RuntimeContext < AbstractRuntimeContext
   @@memory_runtime_contexts = Hash.new
   @@network_runtime_contexts = Hash.new
+  @@ws_runtime_contexts = Hash.new
 
   # accessor get method
   attr_reader :current_command
@@ -22,16 +24,16 @@ class RuntimeContext < AbstractRuntimeContext
   # accessor set method
   attr_writer :current_command
 
-  def initialize(runtime_name, connection_type, tcp_connection_data)
+  def initialize(runtime_name, connection_type, connection_data)
     @runtime_name = runtime_name
     @connection_type = connection_type
-    @tcp_ip_address = tcp_connection_data
+    @connection_data = connection_data
     @current_command = nil
     @interpreter = Interpreter.new
     SdkMessageHelper.send_message_to_app_insights("SdkMessage", RuntimeNameHandler.get_name(@runtime_name).capitalize + " initialized")
   end
 
-  def self.get_instance(runtime_name, connection_type, tcp_connection_data)
+  def self.get_instance(runtime_name, connection_type, connection_data)
     case connection_type
     when ConnectionType::IN_MEMORY
       if @@memory_runtime_contexts.has_key?(runtime_name)
@@ -39,21 +41,31 @@ class RuntimeContext < AbstractRuntimeContext
         runtime_ctx.current_command = nil
         return runtime_ctx
       else
-        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, tcp_connection_data)
+        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, connection_data)
         @@memory_runtime_contexts[runtime_name] = runtime_ctx
         return runtime_ctx
       end
     when ConnectionType::TCP
-      key = runtime_name.to_s + ":" + tcp_connection_data.to_s
+      key = runtime_name.to_s + ":" + connection_data.to_s
       if @@network_runtime_contexts.has_key?(key)
         runtime_ctx = @@network_runtime_contexts[key]
         runtime_ctx.current_command = nil
         return runtime_ctx
       else
-        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, tcp_connection_data)
+        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, connection_data)
         @@network_runtime_contexts[key] = runtime_ctx
         return runtime_ctx
       end
+    when ConnectionType::WEB_SOCKET
+      if @@ws_runtime_contexts.has_key?(key)
+        runtime_ctx = @@ws_runtime_contexts[key]
+        runtime_ctx.current_command = nil
+        return runtime_ctx
+      else
+        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, connection_data)
+        @@ws_runtime_contexts[key] = runtime_ctx
+        return runtime_ctx
+      end
     end
   end
 
@@ -64,7 +76,7 @@ class RuntimeContext < AbstractRuntimeContext
   # The developer can decide at any moment of the materialization for the context, taking full control of the chunks of the expression being transferred and processed on the target runtime.
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/execute-method article on Javonet Guides}
   def execute
-    @response_command = @interpreter.execute(@current_command, @connection_type, @tcp_ip_address)
+    @response_command = @interpreter.execute(@current_command, @connection_type, @connection_data)
     @current_command = nil
 
     if @response_command.command_type == CommandType::EXCEPTION
@@ -94,7 +106,7 @@ class RuntimeContext < AbstractRuntimeContext
   def get_type(*args)
     local_command = Command.new(@runtime_name, CommandType::GET_TYPE, [*args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   # Casts the provided value to a specific type. This method is used when invoking methods that require specific types of arguments.
@@ -106,7 +118,7 @@ class RuntimeContext < AbstractRuntimeContext
   def cast(*args)
     local_command = Command.new(@runtime_name, CommandType::CAST, [*args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   # Retrieves a specific item from an enum type. This method is used when working with enums from the called runtime.
@@ -119,7 +131,7 @@ class RuntimeContext < AbstractRuntimeContext
   def get_enum_item(*args)
     local_command = Command.new(@runtime_name, CommandType::GET_ENUM_ITEM, [*args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   # Creates a reference type argument that can be passed to a method with a ref parameter modifier.
@@ -133,7 +145,7 @@ class RuntimeContext < AbstractRuntimeContext
   def as_ref(*args)
     local_command = Command.new(@runtime_name, CommandType::AS_REF, [*args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   # Creates a reference type argument that can be passed to a method with an out parameter modifier.
@@ -147,7 +159,7 @@ class RuntimeContext < AbstractRuntimeContext
   def as_out(*args)
     local_command = Command.new(@runtime_name, CommandType::AS_OUT, [*args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   # Invokes a function from the called runtime. This method is used when working with functions from the called runtime.
@@ -160,7 +172,7 @@ class RuntimeContext < AbstractRuntimeContext
   def invoke_global_function(function_name, *args)
     local_command = Command.new(@runtime_name, CommandType::INVOKE_GLOBAL_FUNCTION, [function_name, *args])
     @current_command = nil
-    InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
+    InvocationContext.new(@runtime_name, @connection_type, @connection_data, build_command(local_command), false)
   end
 
   def build_command(command)

data/lib/javonet-ruby-sdk/sdk/runtime_factory.rb

@@ -8,64 +8,64 @@ require_relative './../utils/connection_type'
 # # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
 class RuntimeFactory < AbstractRuntimeFactory
 
-  def initialize(connection_type, tcp_connection_data)
+  def initialize(connection_type, connection_data)
     @connection_type = connection_type
-    @tcp_connection_data = tcp_connection_data
+    @connection_data = connection_data
   end
 
   # Creates a RuntimeContext instance to interact with CLR runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the CLR runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def clr
-    RuntimeContext.get_instance(RuntimeName::CLR, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::CLR, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with JVM runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the JVM runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def jvm
-    RuntimeContext.get_instance(RuntimeName::JVM, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::JVM, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with .NET runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the .NET runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def netcore
-    RuntimeContext.get_instance(RuntimeName::NETCORE, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::NETCORE, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Perl runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the Perl runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def perl
-    RuntimeContext.get_instance(RuntimeName::PERL, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::PERL, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Ruby runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the Ruby runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def ruby
-    RuntimeContext.get_instance(RuntimeName::RUBY, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::RUBY, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Node.js runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the Node.js runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def nodejs
-    RuntimeContext.get_instance(RuntimeName::NODEJS, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::NODEJS, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Python runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the Python runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def python
-    RuntimeContext.get_instance(RuntimeName::PYTHON, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::PYTHON, @connection_type, @connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Python2.7 runtime.
   # @return [RuntimeContext] a RuntimeContext instance for the Python2.7 runtime
   # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
   def python27
-    RuntimeContext.get_instance(RuntimeName::PYTHON27, @connection_type, @tcp_connection_data)
+    RuntimeContext.get_instance(RuntimeName::PYTHON27, @connection_type, @connection_data)
   end
 end

data/lib/javonet-ruby-sdk/utils/command_type.rb

@@ -41,6 +41,10 @@ class CommandType
   PASS_DELEGATE = 39
   INVOKE_DELEGATE = 40
   CONVERT_TYPE = 41
+  ADD_EVENT_LISTENER = 42
+  PLUGIN_WRAPPER = 43
+  GET_ASYNC_OPERATION_RESULT = 44
+
 
   def self.get_name(command_number)
     case command_number
@@ -128,6 +132,12 @@ class CommandType
       return 'INVOKE_DELEGATE'
     when 41
       return 'CONVERT_TYPE'
+    when 42
+      return 'ADD_EVENT_LISTENER'
+    when 43
+      return 'PLUGIN_WRAPPER'
+    when 44
+      return 'GET_ASYNC_OPERATION_RESULT'
     else
       raise 'Unknown command type'
     end

data/lib/javonet-ruby-sdk/utils/connection_type.rb

@@ -1,4 +1,5 @@
 class ConnectionType
   IN_MEMORY = 0
   TCP = 1
-end
+  WEB_SOCKET = 2
+end

data/lib/javonet-ruby-sdk/utils/exceptions/exception_serializer.rb

@@ -3,41 +3,61 @@ require_relative './exception_type'
 class ExceptionSerializer
 
   def self.serialize_exception(exception, command)
-    exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
+    exception_command = Command.new(command.runtime_name, CommandType::EXCEPTION, [])
+    begin
+      stack_trace = exception.backtrace
+      exception_message = exception.message
+      exception_name = "Ruby Exception"
+      #exception_name = exception.class.to_s # does not work - causes native issues
 
-    stack_trace = exception.backtrace
-    exception_message = exception.message
-    exception_name = exception.class
-    stack_classes = ""
-    stack_methods = ""
-    stack_lines = ""
-    stack_files = ""
-    stack_trace.each_with_index do |value, index|
-      stack_file, stack_class, stack_line, stack_method = parse_stack_frame(value)
-      unless stack_file.include?("javonet-ruby-sdk") or stack_file.include?("Binaries/Ruby")
-        append_to_string(stack_classes, stack_class)
-        append_to_string(stack_methods, stack_method)
-        append_to_string(stack_lines, stack_line)
-        append_to_string(stack_files, stack_file)
-        if index != stack_trace.length() - 1
-          append_to_string(stack_classes, "|")
-          append_to_string(stack_methods, "|")
-          append_to_string(stack_lines, "|")
-          append_to_string(stack_files, "|")
-        end
+      stack_classes = ""
+      stack_methods = ""
+      stack_lines = ""
+      stack_files = ""
+      if !stack_trace.nil? && !stack_trace.empty?
+        stack_trace.each_with_index do |value, index|
+          stack_file, stack_class, stack_line, stack_method = parse_stack_frame(value)
+          # Extract the file name without the full path - commented for better debugging
+          # To be re-enabled in the future
+          #unless stack_file.include?("javonet-ruby-sdk") or stack_file.include?("Binaries/Ruby")
+            append_to_string(stack_classes, stack_class)
+            append_to_string(stack_methods, stack_method)
+            append_to_string(stack_lines, stack_line)
+            append_to_string(stack_files, stack_file)
+            if index != stack_trace.length - 1
+              append_to_string(stack_classes, "|")
+              append_to_string(stack_methods, "|")
+              append_to_string(stack_lines, "|")
+              append_to_string(stack_files, "|")
+            end
+          #end # To be re-enabled in the future
+          end
       end
-    end
-
-    exception_command = exception_command.add_arg_to_payload(get_exception_code(exception_name.to_s))
-    exception_command = exception_command.add_arg_to_payload(command.to_string)
-    exception_command = exception_command.add_arg_to_payload(exception_name.to_s)
-    exception_command = exception_command.add_arg_to_payload(exception_message)
-    exception_command = exception_command.add_arg_to_payload(stack_classes)
-    exception_command = exception_command.add_arg_to_payload(stack_methods)
-    exception_command = exception_command.add_arg_to_payload(stack_lines)
-    exception_command = exception_command.add_arg_to_payload(stack_files)
 
-    return exception_command
+      exception_command = exception_command.add_arg_to_payload(get_exception_code(exception_name.to_s))
+      exception_command = exception_command.add_arg_to_payload(command.to_string)
+      exception_command = exception_command.add_arg_to_payload(exception_name.to_s)
+      exception_command = exception_command.add_arg_to_payload(exception_message)
+      exception_command = exception_command.add_arg_to_payload(stack_classes)
+      exception_command = exception_command.add_arg_to_payload(stack_methods)
+      exception_command = exception_command.add_arg_to_payload(stack_lines)
+      exception_command = exception_command.add_arg_to_payload(stack_files)
+    rescue Exception => e
+      exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
+      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
+      if command.nil?
+        exception_command = exception_command.add_arg_to_payload("Command is nil")
+      else
+        exception_command = exception_command.add_arg_to_payload(command.to_string)
+      end
+      exception_command = exception_command.add_arg_to_payload("Ruby Exception Serialization Error")
+      exception_command = exception_command.add_arg_to_payload(e.message)
+      exception_command = exception_command.add_arg_to_payload("ExceptionSerializer")
+      exception_command = exception_command.add_arg_to_payload("serialize_exception")
+      exception_command = exception_command.add_arg_to_payload("undefined")
+      exception_command = exception_command.add_arg_to_payload(__FILE__)
+    end
+    exception_command
   end
 
   def self.append_to_string(string, value)
@@ -50,24 +70,38 @@ class ExceptionSerializer
 
   def self.parse_stack_frame(stack_frame)
     # Extract the file path, line number, and method name using regular expressions
-    match = /(.+):(\d+):in `(.+)'/.match(stack_frame)
-
-    # Extract the name of the file without the full path
-    file_name = File.basename(match[1])
-
-    # Extract the class name and method name
-    method_name = match[3]
-    file_name = File.basename(match[1], ".rb")
-    class_name = file_name.split('_').map(&:capitalize).join('')
-    if method_name =~ /(.+)#(.+)/
-      class_name = $1.split('::')[-1]
-      method_name = $2
+    # Handles both 'Class#method' and '<top (required)>'
+    match = /^(.+):(\d+):in ['`](.+)['`]$/.match(stack_frame)
+    return ["undefined", "undefined", "undefined", "undefined"] if match.nil?
+    stack_file = match[1]
+    stack_line = match[2]
+    method_info = match[3]
+    if method_info =~ /^(.+)#(.+)$/
+      stack_class = $1&.split('::')&.last || 'undefined'
+      stack_method = $2
+    elsif method_info =~ /^<(.+)>$/
+      stack_class = "undefined"
+      stack_method = method_info
+    else
+      stack_class = "undefined"
+      stack_method = method_info
     end
-
-    # Return the four variables as an array
-    [match[1], class_name, match[2], method_name]
+    [stack_file, stack_class, stack_line, stack_method]
   end
 
+  # def self.parse_stack_frame(stack_frame)
+  #   # Match: path:line:in 'Class#method'
+  #   match = /^(.+):(\d+):in\s+'([^#]+)#([^']+)'$/.match(stack_frame)
+  #   return ["undefined", "undefined", "undefined", "undefined"] if match.nil?
+  #
+  #   stack_file = match[1]
+  #   stack_line = match[2]
+  #   stack_class = match[3]
+  #   stack_method = match[4]
+  #
+  #   [stack_file, stack_class, stack_line, stack_method]
+  # end
+
   def self.get_exception_code(exception_name)
     case exception_name
     when "Exception"
@@ -87,7 +121,7 @@ class ExceptionSerializer
     when "TypeError"
       return ExceptionType::NULL_POINTER_EXCEPTION
     else
-      return exception_name
+      return ExceptionType::EXCEPTION
     end
   end
 end

data/lib/javonet-ruby-sdk/utils/ws_connection_data.rb

@@ -0,0 +1,19 @@
+class WsConnectionData
+  attr_accessor :hostname
+
+  def initialize(hostname)
+    @hostname = hostname
+  end
+
+  def connection_type
+    ConnectionType::WEB_SOCKET
+  end
+
+  def serialize_connection_data
+    [connection_type, 0, 0, 0, 0, 0, 0]
+  end
+
+  def ==(other)
+    other.is_a?(WsConnectionData) && @hostname == other.hostname
+  end
+end