protobuf-nats 0.12.0.pre0 → 0.13.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2df179aaf5b89613d47a629da54127097597956a5154f6628a27155359796f0
-  data.tar.gz: 23f4c10524cd40ec892fdfea7e8c5545590fe667111d0683cc24a9be47e32b60
+  metadata.gz: 34ffc46779be7a7549af169386c7212ed7210997dba1c1af19326a10aa92f98f
+  data.tar.gz: 9ca966e67099fc4332bcd4dc9270032f0238cf8afa7f18cb57a6c81e4307ed6e
 SHA512:
-  metadata.gz: b4ff63c7224a17541320cbc34e196efead0bf0555f0de5aabf110b2e49bb8c0a45ffc8579c295077ace52b40ade6ee991f332df74dba2e4def0d5a4f69917376
-  data.tar.gz: 1772c0bbafddc6364734dbe25d3618e32c93f6d5194241f1bd54e46e3239902916c9195c184ff95953a6db4d28c9e1dd85d756adc4717fda52e5b0bcef76da26
+  metadata.gz: 4d11137ae46ebfe8a1f003fda41aeba78d4a23893efafb38ad803969ba44df594dd3b0d0b5289e6bface579458baea1327749919f92ecbbbf6e3acbd2235c020
+  data.tar.gz: 5f6b0a643ea4d85063232800dff9fefba05ac70b8787666253244afa474f8314ae6de67b2f10efb970884c47150ce404a78dbf9d18b8ac425727f2172196f836

data/.circleci/config.yml

@@ -0,0 +1,84 @@
+version: 2.1
+
+jobs:
+  build_and_test:
+    parameters:
+      docker_image:
+        type: string
+        description: "The Ruby or JRuby Docker image to test against"
+
+    docker:
+      # 1. The Primary Container (where your code actually runs)
+      - image: << parameters.docker_image >>
+        environment:
+          JRUBY_OPTS: "-J-Xmx1024m"
+          RAILS_ENV: test
+
+      # 2. The Service Container (runs in the background)
+      - image: nats:2.14-linux
+
+    working_directory: ~/project
+
+    steps:
+      - run:
+          name: Install System Dependencies
+          command: |
+            if [ "$(id -u)" = "0" ]; then
+              apt-get update && apt-get install -y build-essential git
+            else
+              sudo apt-get update && sudo apt-get install -y build-essential git
+            fi
+      - checkout
+      # Note: We added the docker_image parameter to the cache key
+      # so MRI and JRuby gems don't conflict.
+      - restore_cache:
+          keys:
+            - v1-gems-<< parameters.docker_image >>-{{ checksum "Gemfile.lock" }}
+            - v1-gems-<< parameters.docker_image >>-
+
+      - run:
+          name: Install Ruby Dependencies
+          command: |
+            gem install bundler
+            bundle config set --local path 'vendor/bundle'
+            bundle install --jobs=4 --retry=3
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-gems-<< parameters.docker_image >>-{{ checksum "Gemfile.lock" }}
+
+      # Wait for NATS to be ready before running tests.
+      # Service containers can sometimes take a few seconds to boot up.
+      - run:
+          name: Wait for NATS
+          command: |
+            if [ "$(id -u)" = "0" ]; then
+              apt-get install -y netcat-openbsd
+            else
+              sudo apt-get install -y netcat-openbsd
+            fi
+
+            echo "Waiting for NATS to start..."
+            while ! nc -z localhost 4222; do
+              sleep 1
+            done
+            echo "NATS is ready!"
+
+      - run:
+          name: Run Tests
+          command: bundle exec rspec
+
+workflows:
+  version: 2
+  ruby_compatibility_matrix:
+    jobs:
+      - build_and_test:
+          name: test-<< matrix.docker_image >>
+          matrix:
+            parameters:
+              docker_image:
+                - "cimg/ruby:3.1"
+                - "cimg/ruby:3.4"
+                - "jruby:9.4"
+                - "jruby:10.0"

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## Changelog
+
+### 0.13.0 - WIP
+- Removed JNats (`nats-pure` is fast enough for JRuby and CRuby parallel work)
+- Added ResponseMuxer (similar to Golang)
+- Added instrumentation when encountering unexpected messages.
+

data/README.md

@@ -49,8 +49,6 @@ used to allow JVM based servers to warm-up slowly to prevent jolts in runtime pe
 
 `PB_NATS_CLIENT_SUBSCRIPTION_POOL_SIZE` - If subscription pooling is desired for the request/response cycle then the pool size maximum should be set; the pool is lazy and therefore will only start new subscriptions as necessary (default: 0)
 
-`PB_NATS_DISABLE_JNATS` - Disable the default jruby jnats client on the jruby platform, use the nats-pure.rb client instead (default: false).
-
 `PROTOBUF_NATS_CONFIG_PATH` - Custom path to the config yaml (default: "config/protobuf_nats.yml").
 
 ### YAML Config
@@ -150,13 +148,20 @@ And we can see the message was sent to the server and the server replied with a
 If we were to add another service endpoint called `search` to the `UserService` but fail to define an instance method
 `search`, then `protobuf-nats` will not subscribe to that route.
 
+## Future Improvements (locked behind ruby version)
+- Migrate to native `Random.new.uuid_v7`
+```ruby
+@prng_lock.synchronize { @prng.uuid_v7(extra_timestamp_bits: 12) }
+```
+- Change ResponseMuxer to use `.pop()` with a timeout.
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-The java-nats client is temporarily forked to support jruby > 9.2.10.0. The living branch for that is here: https://github.com/film42/java-nats/tree/jruby-compat. This will be removed when we upgrade to the new nats.java client.
 
 ## Contributing
 

data/bench/bench.md

@@ -0,0 +1,16 @@
+
+Notes:
+`-Xjit.threshold=0` - Setting the threshold to 0 forces JRuby to compile every method into Java bytecode immediately before its very first execution. This is particularly useful for debugging or bypassing warm-up times during profiling
+
+
+`-Xjit.threshold=10 -J-XX:CompileThreshold=10` - If you are running benchmarks and want both JRuby and the JVM to aggressively optimize early, you can lower both thresholds simultaneously
+
+`bundle;  bx ruby -I lib bench/real_client.rb`
+
+Start local nats server so details can be monitored.
+`/opt/homebrew/opt/nats-server/bin/nats-server -DV -m 8222 -p 4222`
+
+
+```
+export JRUBY_OPTS="--disable:did_you_mean -J-Djava.security.egd=file:/dev/./urandom -J-Xmx2g -J-Xms1024m -J-Xmn512m -Xjit.threshold=10 -J-XX:CompileThreshold=10"
+```

data/bench/console.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "protobuf/nats"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+# ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+# ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "irb"
+IRB.start(__FILE__)

data/bench/real_client.rb

@@ -7,8 +7,8 @@ require "./examples/warehouse/app"
 Protobuf::Logging.logger = ::Logger.new(nil)
 
 Benchmark.ips do |config|
-  config.warmup = 10
-  config.time = 10
+  config.warmup = 30
+  config.time = 30
 
   config.report("single threaded performance") do
     req = Warehouse::Shipment.new(:guid => SecureRandom.uuid)

data/bench/real_client.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=10 -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+# export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+echo "$PWD"
+
+bundle exec ruby -I lib bench/real_client.rb

data/bench/real_client_threaded.rb

@@ -0,0 +1,19 @@
+ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "./examples/warehouse/app"
+
+THREAD_COUNT = ENV.fetch("CLIENT_THREADS",4).to_i
+
+puts "THREAD_COUNT = #{THREAD_COUNT}"
+
+::Protobuf::Logging.logger = ::Logger.new(nil)
+
+while true
+  THREAD_COUNT.times.map do |i|
+    Thread.new do
+      req = Warehouse::Shipment.new(:guid => SecureRandom.uuid, :sleep_time_ms => 5)
+      Warehouse::ShipmentService.client.create(req)
+    end
+  end.each(&:join)
+end

data/bench/real_client_threaded.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=10 -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+export THREAD_COUNT=4
+
+bundle exec ruby -I lib bench/real_client_threaded.rb

data/bench/real_server.sh

@@ -1 +1,16 @@
-PB_SERVER_TYPE="protobuf/nats/runner" PB_CLIENT_TYPE="protobuf/nats/client" bundle exec rpc_server start --threads=20 ./examples/warehouse/app.rb > /dev/null
+#!/bin/bash
+
+# export JRUBY_OPTS="-J-server --disable:did_you_mean -Xcompile.invokedynamic=true -Xjit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false -J-Djava.security.egd=file:/dev/./urandom -J-Xms2g -J-Xmx2g -J-XX:+UseG1GC -J-XX:MaxGCPauseMillis=100"
+
+export JRUBY_OPTS="-J-server -J-Xms4g -J-Xmx4g -J-XX:+AlwaysPreTouch -J-XX:+UseParallelGC -J-XX:ReservedCodeCacheSize=768m -J-XX:MaxInlineLevel=18 -J-XX:MaxInlineSize=100 -J-XX:FreqInlineSize=500 -J-XX:LoopUnrollLimit=250 -J-XX:+UseSuperWord -J-Djruby.jit.threshold=0 -J-Djruby.jit.max=0 -J-Djruby.jit.background=false  -Xcompile.invokedynamic=true"
+
+
+export PB_SERVER_TYPE="protobuf/nats/runner"
+export PB_CLIENT_TYPE="protobuf/nats/client"
+
+export PB_NATS_SERVER_SLOW_START_DELAY=1
+
+export PB_NATS_SERVER_MAX_QUEUE_SIZE=6
+
+bundle exec rpc_server start --threads=10 ./examples/warehouse/app.rb
+

data/examples/warehouse/app.rb

@@ -12,7 +12,6 @@ module Warehouse
   class ShipmentRequest < ::Protobuf::Message; end
   class Shipments < ::Protobuf::Message; end
 
-
   ##
   # Message Fields
   #
@@ -21,6 +20,8 @@ module Warehouse
     optional :string, :address, 2
     optional :double, :price, 3
     optional :string, :package_guid, 4
+
+    optional :int64, :sleep_time_ms, 100
   end
 
   class ShipmentRequest
@@ -33,7 +34,6 @@ module Warehouse
     repeated ::Warehouse::Shipment, :records, 1
   end
 
-
   ##
   # Service Classes
   #
@@ -43,6 +43,12 @@ module Warehouse
     rpc :search, ::Warehouse::ShipmentRequest, ::Warehouse::Shipments
 
     def create
+      # Allows for easier testing of multiple threads
+      if request.sleep_time_ms > 0
+        sleep(request.sleep_time_ms / 1000.0)
+        puts "sleep_time:#{request.sleep_time_ms}"
+      end
+
       respond_with request
     end
 

data/lib/protobuf/nats/client.rb

@@ -1,132 +1,20 @@
+require 'securerandom'
 require "connection_pool"
 require "protobuf/nats"
-require "protobuf/nats/platform"
 require "protobuf/rpc/connectors/base"
 require "monitor"
 
+# Load this independently because we store the class singleton in a const.
+require "protobuf/nats/response_muxer"
+
 module Protobuf
   module Nats
-    class ResponseMuxerRequest
-      def initialize(muxer, token)
-        @muxer = muxer
-        @token = token
-      end
-
-      def publish(subject, data)
-        @muxer.publish(subject, data, @token)
-      end
-
-      def next_message(timeout)
-        @muxer.next_message(@token, timeout)
-      end
-
-      def cleanup
-        @muxer.cleanup(@token)
-      end
-    end
-
-    class ResponseMuxer
-      LOCK = ::Mutex.new
-
-      def initialize
-        @resp_map = Hash.new { |h,k| h[k] = { } }
-      end
-
-      def cleanup(token)
-        @resp_sub.synchronize { @resp_map.delete(token) }
-      end
-
-      def next_message(token, timeout)
-        ::NATS::MonotonicTime::with_nats_timeout(timeout) do
-          @resp_sub.synchronize do
-            break if @resp_map[token].key?(:response) &&
-              !@resp_map[token][:response].empty?
-
-            @resp_map[token][:signal].wait(timeout)
-          end
-        end
-
-        @resp_sub.synchronize { @resp_map[token][:response].shift }
-      end
-
-      def new_request
-        nats = Protobuf::Nats.client_nats_connection
-        token = nats.new_inbox.split('.').last
-        @resp_sub.synchronize do
-          @resp_map[token][:signal] = @resp_sub.new_cond
-        end
-
-        ResponseMuxerRequest.new(self, token)
-      end
-
-      def publish(subject, data, token)
-        nats = Protobuf::Nats.client_nats_connection
-        reply_to = "#{@resp_inbox_prefix}.#{token}"
-        nats.publish(subject, data, reply_to)
-      end
-
-      def restart
-        start unless started?
-
-        LOCK.synchronize do
-          @resp_handler&.kill
-          @started = false
-        end
-
-        start
-      end
-
-      def start
-        return if started?
-        LOCK.synchronize do
-          # We check this twice in case another thread was waiting for the lock to
-          # start this party.
-          return if started?
-
-          nats = ::Protobuf::Nats.client_nats_connection
-          return if nats.nil?
-
-          @resp_inbox_prefix = nats.new_inbox
-          @resp_sub = nats.subscribe("#{@resp_inbox_prefix}.*")
-          @started = true
-        end
-
-        @resp_handler = Thread.new do
-          begin
-            loop do
-              msg = @resp_sub.pending_queue.pop
-              next if msg.nil?
-              @resp_sub.synchronize do
-                # Decrease pending size since consumed already
-                @resp_sub.pending_size -= msg.data.size
-              end
-              token = msg.subject.split('.').last
-
-              @resp_sub.synchronize do
-                # Reject if the token is missing from the request map
-                break unless @resp_map.key?(token)
-
-                signal = @resp_map[token][:signal]
-                @resp_map[token][:response] ||= []
-                @resp_map[token][:response] << msg
-                signal.signal
-              end
-            rescue => error
-              ::Protobuf::Nats.notify_error_callbacks(error)
-              LOCK.synchronize { @started = false }
-            end
-          end
-        end
-      end
-
-      def started?
-        !!@started
-      end
-    end
-
     class Client < ::Protobuf::Rpc::Connectors::Base
 
-      RESPONSE_MUXER = ResponseMuxer.new
+      RESPONSE_MUXER = ::Protobuf::Nats::ResponseMuxer.new
+
+      @subscription_key_cache = {}
+      @subscription_pool_lock = ::Mutex.new
 
       # Structure to hold subscription and inbox to use within pool
       SubscriptionInbox = ::Struct.new(:subscription, :inbox) do
@@ -136,11 +24,26 @@ module Protobuf
         end
       end
 
+      def logger
+        ::Protobuf::Logging.logger
+      end
+
+      def response_muxer
+        RESPONSE_MUXER
+      end
+
       def self.subscription_pool
-        @subscription_pool ||= ::ConnectionPool.new(:size => subscription_pool_size, :timeout => 0.1) do
-          inbox = ::Protobuf::Nats.client_nats_connection.new_inbox
+        return @subscription_pool if @subscription_pool
 
-          SubscriptionInbox.new(::Protobuf::Nats.client_nats_connection.subscribe(inbox), inbox)
+        @subscription_pool_lock.synchronize do
+          # The double-check ensures we don't create a new pool if another
+          # thread created one while we were waiting for the lock.
+          return @subscription_pool if @subscription_pool
+
+          @subscription_pool = ::ConnectionPool.new(:size => subscription_pool_size, :timeout => 0.1) do
+            inbox = ::Protobuf::Nats.client_nats_connection.new_inbox
+            SubscriptionInbox.new(::Protobuf::Nats.client_nats_connection.subscribe(inbox), inbox)
+          end
         end
       end
 
@@ -194,7 +97,7 @@ module Protobuf
       end
 
       def self.subscription_key_cache
-        @subscription_key_cache ||= {}
+        @subscription_key_cache
       end
 
       def ack_timeout
@@ -317,112 +220,59 @@ module Protobuf
         "#{klass}##{method_name}"
       end
 
-      # The Java nats client offers better message queueing so we're going to use
-      # that over locking ourselves. This split in code isn't great, but we can
-      # refactor this later.
-      if ::Protobuf::Nats.jruby?
-
-        # This is a request that expects two responses.
-        # 1. An ACK from the server. We use a shorter timeout.
-        # 2. A PB message from the server. We use a longer timoeut.
-        def nats_request_with_two_responses(subject, data, opts)
-          # Wait for the ACK from the server
-          ack_timeout = opts[:ack_timeout] || 5
-          # Wait for the protobuf response
-          timeout = opts[:timeout] || 60
-
-          nats = ::Protobuf::Nats.client_nats_connection
-
-          # Publish to server
-          with_subscription do |sub_inbox|
-            begin
-              completed_request = false
-
-              if !sub_inbox.subscription.is_valid # replace the subscription if is has been pooled but is no longer valid (maybe a reconnect)
-                nats.unsubscribe(sub_inbox.subscription)
-                sub_inbox.swap(new_subscription_inbox) # this line replaces the sub_inbox in the connection pool if necessary
-              end
-
-              nats.publish(subject, data, sub_inbox.inbox)
-
-              # Wait for reply
-              first_message = nats.next_message(sub_inbox.subscription, ack_timeout)
-              return :ack_timeout if first_message.nil?
-
-              first_message_data = first_message.data
-              return :nack if first_message_data == ::Protobuf::Nats::Messages::NACK
-
-              second_message = nats.next_message(sub_inbox.subscription, timeout)
-              second_message_data = second_message.nil? ? nil : second_message.data
+      def nats_request_with_two_responses(subject, data, opts)
+        # Wait for the ACK from the server
+        ack_timeout = opts[:ack_timeout] || 5
+        # Wait for the protobuf response
+        timeout = opts[:timeout] || 60
 
-              # Check messages
-              response = case ::Protobuf::Nats::Messages::ACK
-                         when first_message_data then second_message_data
-                         when second_message_data then first_message_data
-                         else return :ack_timeout
-                         end
+        nats = Protobuf::Nats.client_nats_connection
 
-              fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
+        # Publish message with the reply topic pointed at the response muxer.
+        req = RESPONSE_MUXER.new_request
+        req.publish(subject, data)
 
-              completed_request = true
-              response
-            ensure
-              if !completed_request
-                nats.unsubscribe(sub_inbox.subscription)
-                sub_inbox.swap(new_subscription_inbox) # this line replaces the sub_inbox in the connection pool if necessary
-              end
-            end
-          end
+        # Receive the first message
+        begin
+          first_message = req.next_message(ack_timeout)
+          logger.debug { "received message with subject:#{first_message.subject}" } if logger.debug?
+        rescue ::NATS::Timeout => e
+          return :ack_timeout
         end
 
-      else
-
-        def nats_request_with_two_responses(subject, data, opts)
-          # Wait for the ACK from the server
-          ack_timeout = opts[:ack_timeout] || 5
-          # Wait for the protobuf response
-          timeout = opts[:timeout] || 60
+        # Check for a NACK
+        return :nack if first_message.data == ::Protobuf::Nats::Messages::NACK
 
-          nats = Protobuf::Nats.client_nats_connection
-
-          # Publish message with the reply topic pointed at the response muxer.
-          req = RESPONSE_MUXER.new_request
-          req.publish(subject, data)
-
-          # Receive the first message
-          begin
-            first_message = req.next_message(ack_timeout)
-          rescue ::NATS::Timeout => e
-            return :ack_timeout
-          end
-
-          # Check for a NACK
-          return :nack if first_message.data == ::Protobuf::Nats::Messages::NACK
-
-          # Receive the second message
-          begin
-            second_message = req.next_message(timeout)
-          rescue ::NATS::Timeout
-            # ignore to raise a repsonse timeout below
-          end
+        # Receive the second message
+        begin
+          second_message = req.next_message(timeout)
+        rescue ::NATS::Timeout
+          # ignore to raise a repsonse timeout below
+        end
 
-          # NOTE: This might be nil, so be careful checking the data value
-          second_message_data = second_message&.data
+        # NOTE: This might be nil, so be careful checking the data value
+        second_message_data = second_message&.data
 
-          # Check messages
-          response = case ::Protobuf::Nats::Messages::ACK
-                     when first_message.data then second_message_data
-                     when second_message_data then first_message.data
-                     else return :ack_timeout
-                     end
+        # This should never happen, if it does, then return an :ack_timeout because something went wrong
+        if first_message&.data == ::Protobuf::Nats::Messages::ACK &&
+          second_message&.data == ::Protobuf::Nats::Messages::ACK
+          logger.warn "received ACK/ACK message."
+          return :ack_timeout
+        end
 
-          fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
+        # Check messages
+        response = case ::Protobuf::Nats::Messages::ACK
+                   when first_message&.data then second_message_data
+                   when second_message&.data then first_message&.data
+                   else return :ack_timeout
+                   end
 
-          response
-        ensure
-          req.cleanup if req
-        end
+        fail(::Protobuf::Nats::Errors::ResponseTimeout, formatted_service_and_method_name) unless response
 
+        response
+      ensure
+        # cleanup the token from the request map
+        req.cleanup if req
       end
 
     end

data/lib/protobuf/nats/config.rb

@@ -1,3 +1,4 @@
+require "erb"
 require "openssl"
 require "yaml"
 
@@ -39,12 +40,13 @@ module Protobuf
             yaml_config = {}
             config_path = ENV["PROTOBUF_NATS_CONFIG_PATH"] || ::File.join("config", "protobuf_nats.yml")
             absolute_config_path = ::File.expand_path(config_path)
-            if ::File.exists?(absolute_config_path)
+            if ::File.exist?(absolute_config_path)
+              yaml_string = ::ERB.new(::File.read(absolute_config_path)).result
               # Psych 4 and newer requires unsafe_load_file in order for aliases to be used
               yaml_config = if ::YAML.respond_to?(:unsafe_load_file)
-                ::YAML.unsafe_load_file(absolute_config_path)[env]
+                ::YAML.unsafe_load(yaml_string)[env]
               else
-                ::YAML.load_file(absolute_config_path)[env]
+                ::YAML.load(yaml_string)[env]
               end
             end
 

data/lib/protobuf/nats/errors.rb

@@ -10,14 +10,13 @@ module Protobuf
       class ResponseTimeout < ClientError
       end
 
+      class ResponseMuxer < ClientError
+      end
+
       class MriIOException < ::StandardError
       end
 
-      IOException = if defined? JRUBY_VERSION
-                      java.io.IOException
-                    else
-                      MriIOException
-                    end
+      IOException = MriIOException
     end
   end
 end