event_store_client 2.1.5 → 2.3.0.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4b94342dbb48eeba88c4f87758497bf3604ec01d1954163af2d9add2e88e46f
-  data.tar.gz: 195564b4fded0a7c5986b4f3b5b76a19ad97018113238389a26254df27191f49
+  metadata.gz: 96e1f2743b3265c8776ffe39636f086af2be0bc19ff46e693f1fbf7373eeb3d4
+  data.tar.gz: 7595e367ccced285bb4e061d9875bf6ba84d9e999aa60f404609f0258aea1426
 SHA512:
-  metadata.gz: 62c2faaed828d92add77f8c8af76f7bae5fe3fa990e9820e4fc5dd6b74ad7b3fbe0e84aa7d2975c6903e91e959d6969d5ae30aa3d2916300086d2cfa81fce8b0
-  data.tar.gz: 5b282b014013149ecb61531ad02fe654321765f15da09fc4ffeadabc2fbefc21c919a769d657cfc0fe7922d80338dab6908bf1a00a21b672d9128603062e448f
+  metadata.gz: 88e2b3324a0b59773f39077ad954e8a0f98ca0fd0bd67217a67c742bdc5ae6efbdf36878a0feeff9e2532e8f1d97f5a6eee0581268dc24cda631728fe5fc65d3
+  data.tar.gz: 73be7b894f397e323807adec3667b78ddc7f7b5973942cb7d77cb5872af1d6b01eee9f9e7c7440db213d3ea3fb23256e99066ce4d0e23af3c26bbd14c3c4bb56

data/docs/configuration.md

@@ -6,15 +6,52 @@ Currently only one setup is supported. For example, you can't configure a connec
 
 Configuration options:
 
-| name                 | value                                                                                | default value                           | description                                                                                                                                                                                                                              |
-|----------------------|--------------------------------------------------------------------------------------|-----------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| eventstore_url      | String                                                                               | `'esdb://localhost:2113'`               | Connection string. See description of possible values below.                                                                                                                                                                            |
-| per_page             | Integer                                                                              | `20`                                    | Number of events to return in one response.                                                                                                                                                                                              |
-| mapper               | `EventStoreClient::Mapper::Default.new` or `EventStoreClient::Mapper::Encrypted.new` | `EventStoreClient::Mapper::Default.new` | An object that is responsible for serialization / deserialization and encryption / decryption of events.                                                                                                                                     |
-| default_event_class  | `DeserializedEvent` or any class, inherited from it                                  | `DeserializedEvent`                     | This class will be used during the deserialization process when deserializer fails to resolve an event's class from response.                                                                                                             |
-| logger               | `Logger`                                                                             | `nil`                                   | A logger that would log messages from `event_store_client` and `grpc` gems.                                                                                                                                                               |
-| skip_deserialization | Boolean                                                                              | `false`                                 | Whether to skip event deserialization using the given `mapper` setting. If you set it to `true` decryption will be skipped as well. It is useful when you want to defer deserialization and handle it later by yourself. |
-| skip_decryption      | Boolean                                                                              | `false`                                 | Whether to skip decrypting encrypted event payloads.                                                                                                                                                                                                       |
+| name                 | value                                                                                | default value                                                                                                                     | description                                                                                                                                                                                                                                           |
+|----------------------|--------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| eventstore_url      | String                                                                               | `'esdb://localhost:2113'`                                                                                                         | Connection string. See description of possible values below.                                                                                                                                                                                          |
+| per_page             | Integer                                                                              | `20`                                                                                                                              | Number of events to return in one response.                                                                                                                                                                                                           |
+| mapper               | `EventStoreClient::Mapper::Default.new` or `EventStoreClient::Mapper::Encrypted.new` | `EventStoreClient::Mapper::Default.new`                                                                                           | An object that is responsible for serialization / deserialization and encryption / decryption of events.                                                                                                                                              |
+| default_event_class  | `DeserializedEvent` or any class, inherited from it                                  | `DeserializedEvent`                                                                                                               | This class will be used during the deserialization process when deserializer fails to resolve an event's class from response.                                                                                                                         |
+| logger               | `Logger`                                                                             | `nil`                                                                                                                             | A logger that would log messages from `event_store_client` and `grpc` gems.                                                                                                                                                                           |
+| skip_deserialization | Boolean                                                                              | `false`                                                                                                                           | Whether to skip event deserialization using the given `mapper` setting. If you set it to `true` decryption will be skipped as well. It is useful when you want to defer deserialization and handle it later by yourself.                              |
+| skip_decryption      | Boolean                                                                              | `false`                                                                                                                           | Whether to skip decrypting encrypted event payloads.                                                                                                                                                                                                  |
+| channel_args      | Hash                                                                                 | `{ 'grpc.min_reconnect_backoff_ms' => 100, 'grpc.max_reconnect_backoff_ms' => 100, 'grpc.initial_reconnect_backoff_ms' => 100 }` | GRPC-specific connection options. This hash will be passed into the `:channel_args` argument of a Stub class of your request. More GRPC options can be found [here](https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h). |
+
+## A note about channel_args option
+
+When defining the custom value of this option - the default value will be reverse-merged into it. So, for example, if you would like to set `grpc.min_reconnect_backoff_ms` like so:
+
+```ruby
+EventStoreClient.configure do |config|
+  config.channel_args = { 'grpc.min_reconnect_backoff_ms' => 200 }
+end
+```
+
+the resulting `channel_args` value will be
+
+```ruby
+{ 
+  "grpc.min_reconnect_backoff_ms" => 200, 
+  "grpc.max_reconnect_backoff_ms" => 100, 
+  "grpc.initial_reconnect_backoff_ms" => 100
+}
+```
+
+This behaviour is intentional. So, if you want to override them all - you should do it explicitly. Example:
+
+```ruby
+EventStoreClient.configure do |config|
+  config.channel_args = { 
+    'grpc.min_reconnect_backoff_ms' => 500,
+    'grpc.max_reconnect_backoff_ms' => 500,
+    'grpc.initial_reconnect_backoff_ms' => 500
+  }
+end
+```
+
+It could be useful when you have high ping to your EventStore DB server.
+
+Besides, there is an option which you can't change - `grpc.enable_retries`. It always defaults to `0`. This is because `event_store_client` implements its own retry functional.
 
 ## Connection string
 
@@ -91,3 +128,50 @@ esdb://localhost:2113/?tls=false
 esdb+discover://localhost:2113/?grpcRetryAttempts=3&grpcRetryInterval=300&discoverInterval=200
 esdb://localhost:2113,localhost:2114,localhost:2115/?gossipTimeout=500&maxDiscoverAttempts=3
 ```
+
+### Multiple configurations
+
+`event_store_client` provides a possibility to configure as much connections as you want. To do so, you have to name your configuration, and later provide that name to `EventStoreClient` client.
+
+Setup your configs:
+```ruby
+EventStoreClient.configure(name: :es_db_1) do |config|
+  # adjust your config here
+  config.eventstore_url = 'esdb://localhost:2113'
+end
+EventStoreClient.configure(name: :es_db_2) do |config|
+  # adjust your second config here
+  config.eventstore_url = 'esdb://localhost:2114' 
+end
+```
+
+Tell `EventStoreClient` which config you want to use:
+
+```ruby
+client1 = EventStoreClient.client(config_name: :es_db_1)
+client2 = EventStoreClient.client(config_name: :es_db_2)
+# Read from $all stream using :es_db_1 config
+client1.read('$all')
+# Read from $all stream using :es_db_2 config
+client2.read('$all')
+```
+
+#### Default config
+
+If you only have one config - you don't have to bother naming it or passing a config name to the client when performing any operations. You can configure it as usual.
+
+Setup your default config:
+```ruby
+EventStoreClient.configure do |config|
+  # config goes here
+  config.eventstore_url = 'esdb://localhost:2113' 
+end
+```
+
+Use it:
+
+```ruby
+client = EventStoreClient.client
+# Read from $all stream using your default config
+client.read('$all')
+```

data/lib/event_store_client/adapters/grpc/client.rb

@@ -5,7 +5,13 @@
 module EventStoreClient
   module GRPC
     class Client
-      include Configuration
+      attr_reader :config
+      private :config
+
+      # @param config [EventStoreClient::Config]
+      def initialize(config)
+        @config = config
+      end
 
       # @param stream_name [String]
       # @param events_or_event [EventStoreClient::DeserializedEvent, Array<EventStoreClient::DeserializedEvent>]
@@ -30,11 +36,11 @@ module EventStoreClient
       #   Returns monads' Success/Failure in case whether request was performed.
       def append_to_stream(stream_name, events_or_event, options: {}, credentials: {}, &blk)
         if events_or_event.is_a?(Array)
-          Commands::Streams::AppendMultiple.new(**credentials).call(
+          Commands::Streams::AppendMultiple.new(config: config, **credentials).call(
             stream_name, events_or_event, options: options
           )
         else
-          Commands::Streams::Append.new(**credentials).call(
+          Commands::Streams::Append.new(config: config, **credentials).call(
             stream_name, events_or_event, options: options, &blk
           )
         end
@@ -91,7 +97,7 @@ module EventStoreClient
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def read(stream_name, options: {}, skip_deserialization: config.skip_deserialization,
                skip_decryption: config.skip_decryption, credentials: {}, &blk)
-        Commands::Streams::Read.new(**credentials).call(
+        Commands::Streams::Read.new(config: config, **credentials).call(
           stream_name,
           options: options,
           skip_deserialization: skip_deserialization,
@@ -106,7 +112,7 @@ module EventStoreClient
       def read_paginated(stream_name, options: {}, credentials: {},
                          skip_deserialization: config.skip_deserialization,
                          skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::ReadPaginated.new(**credentials).call(
+        Commands::Streams::ReadPaginated.new(config: config, **credentials).call(
           stream_name,
           options: options,
           skip_deserialization: skip_deserialization,
@@ -133,7 +139,9 @@ module EventStoreClient
       #     ```
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def hard_delete_stream(stream_name, options: {}, credentials: {}, &blk)
-        Commands::Streams::HardDelete.new(**credentials).call(stream_name, options: options, &blk)
+        Commands::Streams::HardDelete.
+          new(config: config, **credentials).
+          call(stream_name, options: options, &blk)
       end
 
       # Refs https://developers.eventstore.com/server/v5/streams.html#soft-delete-and-truncatebefore
@@ -154,7 +162,9 @@ module EventStoreClient
       #     ```
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def delete_stream(stream_name, options: {}, credentials: {}, &blk)
-        Commands::Streams::Delete.new(**credentials).call(stream_name, options: options, &blk)
+        Commands::Streams::Delete.
+          new(config: config, **credentials).
+          call(stream_name, options: options, &blk)
       end
 
       # Subscribe to the given stream and listens for events. Note, that it will block execution of
@@ -213,7 +223,7 @@ module EventStoreClient
       def subscribe_to_stream(stream_name, handler:, options: {}, credentials: {},
                               skip_deserialization: config.skip_deserialization,
                               skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::Subscribe.new(**credentials).call(
+        Commands::Streams::Subscribe.new(config: config, **credentials).call(
           stream_name,
           handler: handler,
           options: options,
@@ -229,7 +239,7 @@ module EventStoreClient
       def subscribe_to_all(handler:, options: {}, credentials: {},
                            skip_deserialization: config.skip_deserialization,
                            skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::Subscribe.new(**credentials).call(
+        Commands::Streams::Subscribe.new(config: config, **credentials).call(
           '$all',
           handler: handler,
           options: options,
@@ -246,14 +256,14 @@ module EventStoreClient
       # @see #append_to_stream for available params and returned value
       def link_to(stream_name, events_or_event, options: {}, credentials: {}, &blk)
         if events_or_event.is_a?(Array)
-          Commands::Streams::LinkToMultiple.new(**credentials).call(
+          Commands::Streams::LinkToMultiple.new(config: config, **credentials).call(
             stream_name,
             events_or_event,
             options: options,
             &blk
           )
         else
-          Commands::Streams::LinkTo.new(**credentials).call(
+          Commands::Streams::LinkTo.new(config: config, **credentials).call(
             stream_name,
             events_or_event,
             options: options,
@@ -267,7 +277,7 @@ module EventStoreClient
       # @option credentials [String] :password
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def cluster_info(credentials: {})
-        Commands::Gossip::ClusterInfo.new(**credentials).call
+        Commands::Gossip::ClusterInfo.new(config: config, **credentials).call
       end
     end
   end

data/lib/event_store_client/adapters/grpc/cluster/gossip_discover.rb

@@ -6,8 +6,6 @@ module EventStoreClient
   module GRPC
     module Cluster
       class GossipDiscover
-        include Configuration
-
         DiscoverError = Class.new(StandardError)
 
         # Order is important - it plays role of states priority as well
@@ -15,6 +13,14 @@ module EventStoreClient
         ALLOWED_NODE_STATES =
           (%i[Leader Follower] + READ_ONLY_STATES).freeze
 
+        attr_reader :config
+        private :config
+
+        # @param config [EventStoreClient::Config]
+        def initialize(config:)
+          @config = config
+        end
+
         # @param nodes [Array<EventStoreClient::Connection::Url::Node>]
         # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
         # @return [EventStoreClient::GRPC::Cluster::Member]
@@ -58,7 +64,8 @@ module EventStoreClient
           connection = Connection.new(
             host: node.host,
             port: node.port,
-            timeout: config.eventstore_url.gossip_timeout
+            timeout: config.eventstore_url.gossip_timeout,
+            config: config
           )
           members =
             connection.

data/lib/event_store_client/adapters/grpc/cluster/insecure_connection.rb

@@ -11,7 +11,7 @@ module EventStoreClient
           stub_class.new(
             "#{host}:#{port}",
             :this_channel_is_insecure,
-            channel_args: channel_args,
+            channel_args: config.channel_args,
             timeout: (timeout / 1000.0 if timeout)
           )
         end

data/lib/event_store_client/adapters/grpc/cluster/queryless_discover.rb

@@ -4,10 +4,16 @@ module EventStoreClient
   module GRPC
     module Cluster
       class QuerylessDiscover
-        include Configuration
-
         NoHostError = Class.new(StandardError)
 
+        attr_reader :config
+        private :config
+
+        # @param config [EventStoreClient::Config]
+        def initialize(config:)
+          @config = config
+        end
+
         # @param nodes [EventStoreClient::Connection::Url::Node]
         # @return [EventStoreClient::GRPC::Cluster::Member]
         def call(nodes)

data/lib/event_store_client/adapters/grpc/cluster/secure_connection.rb

@@ -13,7 +13,7 @@ module EventStoreClient
           stub_class.new(
             "#{host}:#{port}",
             channel_credentials,
-            channel_args: channel_args,
+            channel_args: config.channel_args,
             timeout: (timeout / 1000.0 if timeout)
           )
         end

data/lib/event_store_client/adapters/grpc/commands/command.rb

@@ -14,19 +14,20 @@ module EventStoreClient
           end
         end
 
-        include Configuration
         include Dry::Monads[:try, :result]
 
-        attr_reader :connection
-        private :connection
+        attr_reader :connection, :config
+        private :connection, :config
 
+        # @param config [EventStoreClient::Config]
         # @param conn_options [Hash]
         # @option conn_options [String] :host
         # @option conn_options [Integer] :port
         # @option conn_options [String] :username
         # @option conn_options [String] :password
-        def initialize(**conn_options)
-          @connection = EventStoreClient::GRPC::Connection.new(**conn_options)
+        def initialize(config:, **conn_options)
+          @config = config
+          @connection = EventStoreClient::GRPC::Connection.new(config: config, **conn_options)
         end
 
         # Override it in your implementation of command.
@@ -74,6 +75,7 @@ module EventStoreClient
               config.logger&.debug("Request failed. Reason: #{e.class}. Retying.")
               retry
             end
+            Discover.current_member(config: config)&.failed_endpoint = true
             raise
           end
         end

data/lib/event_store_client/adapters/grpc/commands/streams/append_multiple.rb

@@ -12,7 +12,9 @@ module EventStoreClient
           def call(stream_name, events, options:, &blk)
             result = []
             events.each.with_index do |event, index|
-              response = Commands::Streams::Append.new(**connection_options).call(
+              response = Commands::Streams::Append.new(
+                config: config, **connection_options
+              ).call(
                 stream_name, event, options: options
               ) do |req_opts, proposed_msg_opts|
                 req_opts.options.revision += index if has_revision_option?(req_opts.options)

data/lib/event_store_client/adapters/grpc/commands/streams/link_to.rb

@@ -7,7 +7,7 @@ module EventStoreClient
         class LinkTo < Command
           # @see {EventStoreClient::GRPC::Client#hard_delete_stream}
           def call(stream_name, event, options:, &blk)
-            append_cmd = Append.new(**connection_options)
+            append_cmd = Append.new(config: config, **connection_options)
             link_event = DeserializedEvent.new(
               id: event.id, type: DeserializedEvent::LINK_TYPE, data: event.title
             )

data/lib/event_store_client/adapters/grpc/commands/streams/link_to_multiple.rb

@@ -11,12 +11,11 @@ module EventStoreClient
           # @see {EventStoreClient::GRPC::Client#link_to}
           def call(stream_name, events, options:, &blk)
             result = []
-            link_cmd = Commands::Streams::LinkTo.new(**connection_options)
+            link_cmd = Commands::Streams::LinkTo.new(config: config, **connection_options)
             events.each.with_index do |event, index|
               response =
                 link_cmd.call(stream_name, event, options: options) do |req_opts, proposed_msg_opts|
                   req_opts.options.revision += index if has_revision_option?(req_opts.options)
-
                   yield(req_opts, proposed_msg_opts) if blk
                 end
               result.push(response)

data/lib/event_store_client/adapters/grpc/commands/streams/read.rb

@@ -15,7 +15,7 @@ module EventStoreClient
             yield options if block_given?
             result =
               retry_request { service.read(request.new(options: options), metadata: metadata).to_a }
-            EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
+            EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new(config: config).call(
               result,
               skip_deserialization,
               skip_decryption
@@ -28,7 +28,10 @@ module EventStoreClient
           # @param options [Hash]
           # @return [EventStore::Client::Streams::ReadReq::Options]
           def normalize_options(stream_name, options)
-            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            options =
+              Options::Streams::ReadOptions.
+                new(stream_name, options, config: config).
+                request_options
             EventStore::Client::Streams::ReadReq::Options.new(options)
           end
         end

data/lib/event_store_client/adapters/grpc/commands/streams/read_paginated.rb

@@ -22,7 +22,7 @@ module EventStoreClient
             Enumerator.new do |yielder|
               loop do
                 response =
-                  Read.new(**connection_options).call(
+                  Read.new(config: config, **connection_options).call(
                     stream_name,
                     options: options,
                     skip_deserialization: true,
@@ -45,11 +45,13 @@ module EventStoreClient
                   raise StopIteration
                 end
                 processed_response =
-                  EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
-                    response.success,
-                    skip_deserialization,
-                    skip_decryption
-                  )
+                  EventStoreClient::GRPC::Shared::Streams::ProcessResponses.
+                    new(config: config).
+                    call(
+                      response.success,
+                      skip_deserialization,
+                      skip_decryption
+                    )
                 yielder << processed_response if processed_response.success.any?
                 raise StopIteration if end_reached?(response.success, max_count)
 

data/lib/event_store_client/adapters/grpc/commands/streams/subscribe.rb

@@ -20,7 +20,7 @@ module EventStoreClient
             yield options if block_given?
 
             callback = proc do |response|
-              result = Shared::Streams::ProcessResponse.new.call(
+              result = Shared::Streams::ProcessResponse.new(config: config).call(
                 response,
                 skip_deserialization,
                 skip_decryption
@@ -41,7 +41,10 @@ module EventStoreClient
           # @param options [Hash]
           # @return [EventStore::Client::Streams::ReadReq::Options]
           def normalize_options(stream_name, options)
-            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            options =
+              Options::Streams::ReadOptions.
+                new(stream_name, options, config: config).
+                request_options
             EventStore::Client::Streams::ReadReq::Options.new(options).tap do |opts|
               opts.subscription =
                 EventStore::Client::Streams::ReadReq::Options::SubscriptionOptions.new

data/lib/event_store_client/adapters/grpc/connection.rb

@@ -7,18 +7,7 @@ require 'net/http'
 module EventStoreClient
   module GRPC
     class Connection
-      include Configuration
-      include Extensions::OptionsExtension
-
-      option(:host) { Discover.current_member.host }
-      option(:port) { Discover.current_member.port }
-      option(:username) { config.eventstore_url.username }
-      option(:password) { config.eventstore_url.password }
-      option(:timeout) { config.eventstore_url.timeout }
-
       class << self
-        include Configuration
-
         # Resolve which connection class we instantiate, based on config.eventstore_url.tls config
         # option. If :new method is called from SecureConnection or InsecureConnection class - then
         # that particular class will be instantiated despite on config.eventstore_url.tls config
@@ -35,13 +24,14 @@ module EventStoreClient
         #   Cluster::InsecureConnection.new
         #   # => #<EventStoreClient::GRPC::Cluster::InsecureConnection>
         #   ```
-        def new(*args, **kwargs, &blk)
+        # @param config [EventStoreClient::Config]
+        def new(config:, **options)
           return super unless self == Connection
 
           if config.eventstore_url.tls
-            Cluster::SecureConnection.new(*args, **kwargs, &blk)
+            Cluster::SecureConnection.new(config: config, **options)
           else
-            Cluster::InsecureConnection.new(*args, **kwargs, &blk)
+            Cluster::InsecureConnection.new(config: config, **options)
           end
         end
 
@@ -52,25 +42,24 @@ module EventStoreClient
         end
       end
 
-      def call(stub_class)
-        raise NotImplementedError
-      end
+      include Extensions::OptionsExtension
+
+      option(:host) { Discover.current_member(config: config).host }
+      option(:port) { Discover.current_member(config: config).port }
+      option(:username) { config.eventstore_url.username }
+      option(:password) { config.eventstore_url.password }
+      option(:timeout) { config.eventstore_url.timeout }
 
-      private
+      attr_reader :config
+      private :config
 
-      # Common channel arguments for all GRPC requests.
-      # Available channel arguments are described here
-      # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h
-      # @return [Hash]
-      def channel_args
-        {
-          # disable build-in GRPC retries functional
-          'grpc.enable_retries' => 0,
-          # These three options reduce delays between failed requests.
-          'grpc.min_reconnect_backoff_ms' => 100, # milliseconds
-          'grpc.max_reconnect_backoff_ms' => 100, # milliseconds
-          'grpc.initial_reconnect_backoff_ms' => 100 # milliseconds
-        }
+      def initialize(config:, **options)
+        @config = config
+        super
+      end
+
+      def call(stub_class)
+        raise NotImplementedError
       end
     end
   end

data/lib/event_store_client/adapters/grpc/discover.rb

@@ -5,55 +5,75 @@
 module EventStoreClient
   module GRPC
     class Discover
-      include Configuration
-
       class << self
+        # @param config [EventStoreClient::Config]
         # @return [EventStoreClient::GRPC::Cluster::Member]
-        def current_member
-          @exception = nil
-          return @current_member if member_alive?
-
-          semaphore.synchronize do
-            raise @exception if @exception
-            return @current_member if member_alive?
-
-            failed_member = @current_member if @current_member&.failed_endpoint
-            @current_member =
-              begin
-                new.call(failed_member: failed_member)
-              rescue StandardError => e
-                @exception = e
-                nil
-              end
+        def current_member(config:)
+          @exception[config.name] = nil
+          return @current_member[config.name] if member_alive?(@current_member[config.name])
+
+          semaphore(config.name).synchronize do
+            current_member = @current_member[config.name]
+            raise @exception[config.name] if @exception[config.name]
+            return current_member if member_alive?(current_member)
+
+            failed_member = current_member&.failed_endpoint ? current_member : nil
+            begin
+              @current_member[config.name] = new(config: config).call(failed_member: failed_member)
+            rescue StandardError => e
+              @exception[config.name] = e
+              @current_member[config.name] = nil
+              raise
+            end
           end
-          raise @exception if @exception
 
-          @current_member
+          @current_member[config.name]
         end
 
+        # @param member [EventStoreClient::GRPC::Cluster::Member, nil]
         # @return [Boolean]
-        def member_alive?
-          return false if @current_member&.failed_endpoint
+        def member_alive?(member)
+          return false if member&.failed_endpoint
+
+          !member.nil?
+        end
 
-          !@current_member.nil?
+        # @return [void]
+        def init_default_discover_vars
+          @exception = {}
+          @current_member = {}
+          @semaphore = {}
         end
 
         private
 
+        # @param config_name [String, Symbol]
         # @return [Thread::Mutex]
-        def semaphore
-          @semaphore ||= Thread::Mutex.new
+        def semaphore(config_name)
+          @semaphore[config_name] ||= Thread::Mutex.new
         end
       end
 
+      init_default_discover_vars
+
+      attr_reader :config
+      private :config
+
+      # @param config [EventStoreClient::Config]
+      def initialize(config:)
+        @config = config
+      end
+
       # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
       # @return [EventStoreClient::GRPC::Cluster::Member]
       def call(failed_member: nil)
         if needs_discover?
-          return Cluster::GossipDiscover.new.call(nodes, failed_member: failed_member)
+          discovery =
+            Cluster::GossipDiscover.new(config: config).call(nodes, failed_member: failed_member)
+          return discovery
         end
 
-        Cluster::QuerylessDiscover.new.call(config.eventstore_url.nodes.to_a)
+        Cluster::QuerylessDiscover.new(config: config).call(config.eventstore_url.nodes.to_a)
       end
 
       private

data/lib/event_store_client/adapters/grpc/options/streams/read_options.rb

@@ -7,10 +7,8 @@ module EventStoreClient
     module Options
       module Streams
         class ReadOptions
-          include Configuration
-
-          attr_reader :options, :stream_name
-          private :options, :stream_name
+          attr_reader :options, :stream_name, :config
+          private :options, :stream_name, :config
 
           # @param stream_name [String]
           # @param options [Hash]
@@ -39,9 +37,11 @@ module EventStoreClient
           # @option [Hash] :filter see
           #   {EventStoreClient::GRPC::Shared::Options::FilterOptions#initialize} for available
           #   values
-          def initialize(stream_name, options)
+          # @param config [EventStoreClient::Config]
+          def initialize(stream_name, options, config:)
             @stream_name = stream_name
             @options = options
+            @config = config
           end
 
           # @return [Hash] see event_store.client.streams.ReadReq.Options for available options

data/lib/event_store_client/adapters/grpc/shared/streams/process_response.rb

@@ -6,7 +6,14 @@ module EventStoreClient
       module Streams
         class ProcessResponse
           include Dry::Monads[:result]
-          include Configuration
+
+          attr_reader :config
+          private :config
+
+          # @param config [EventStoreClient::Config]
+          def initialize(config:)
+            @config = config
+          end
 
           # @api private
           # @param response [EventStore::Client::Streams::ReadResp]

data/lib/event_store_client/adapters/grpc/shared/streams/process_responses.rb

@@ -6,7 +6,14 @@ module EventStoreClient
       module Streams
         class ProcessResponses
           include Dry::Monads[:result]
-          include Configuration
+
+          attr_reader :config
+          private :config
+
+          # @param config [EventStoreClient::Config]
+          def initialize(config:)
+            @config = config
+          end
 
           # @api private
           # @param responses [Array<EventStore::Client::Streams::ReadResp>]

data/lib/event_store_client/config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  class Config
+    include Extensions::OptionsExtension
+
+    CHANNEL_ARGS_DEFAULTS = {
+      # These three options reduce delays between failed requests.
+      'grpc.min_reconnect_backoff_ms' => 100, # milliseconds
+      'grpc.max_reconnect_backoff_ms' => 100, # milliseconds
+      'grpc.initial_reconnect_backoff_ms' => 100 # milliseconds
+    }.freeze
+
+    option(:eventstore_url) { 'esdb://localhost:2113' }
+    option(:per_page) { 20 }
+    option(:mapper) { Mapper::Default.new(config: self) }
+    option(:default_event_class) { DeserializedEvent }
+    option(:logger)
+    option(:skip_deserialization) { false }
+    option(:skip_decryption) { false }
+    # GRPC-specific connection options. This hash will be passed into the `:channel_args` argument
+    # of a Stub class of your request. More GRPC options can be found here
+    # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h
+    option(:channel_args) # Hash
+    option(:name) { :default }
+
+    def eventstore_url=(value)
+      @eventstore_url =
+        if value.is_a?(Connection::Url)
+          value
+        else
+          Connection::UrlParser.new.call(value)
+        end
+    end
+
+    # @param logger [Logger, nil]
+    # @return [Logger, nil]
+    def logger=(logger)
+      ::GRPC.define_singleton_method :logger do
+        @logger ||= logger.nil? ? ::GRPC::DefaultLogger::NoopLogger.new : logger
+      end
+      @logger = logger
+    end
+
+    # @param val [Hash, nil]
+    # @return [Hash]
+    def channel_args=(val)
+      channel_args = CHANNEL_ARGS_DEFAULTS.merge(val&.transform_keys(&:to_s) || {})
+      # This options always defaults to `0`. This is because `event_store_client` implements its
+      # own retry functional.
+      channel_args['grpc.enable_retries'] = 0
+      @channel_args = channel_args
+    end
+  end
+end

data/lib/event_store_client/connection/url.rb

@@ -52,6 +52,14 @@ module EventStoreClient
       option(:grpc_retry_attempts) { 3 }
       # Delay between GRPC request retries
       option(:grpc_retry_interval) { 100 } # milliseconds
+
+      # @param other [EventStoreClient::Connection::Url, Object]
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a?(Url)
+
+        options_hash == other.options_hash
+      end
     end
   end
 end

data/lib/event_store_client/data_decryptor.rb

@@ -2,8 +2,6 @@
 
 module EventStoreClient
   class DataDecryptor
-    include Configuration
-
     KeyNotFoundError = Class.new(StandardError)
 
     def call

data/lib/event_store_client/mapper/default.rb

@@ -5,12 +5,14 @@
 module EventStoreClient
   module Mapper
     class Default
-      attr_reader :serializer
-      private :serializer
+      attr_reader :serializer, :config
+      private :serializer, :config
 
+      # @param config [EventStoreClient::Config]
       # @param serializer [#serialize, #deserialize]
-      def initialize(serializer: Serializer::Json)
+      def initialize(config:, serializer: Serializer::Json)
         @serializer = serializer
+        @config = config
       end
 
       # @param event [EventStoreClient::DeserializedEvent]
@@ -24,7 +26,9 @@ module EventStoreClient
       def deserialize(event_or_raw_event, **)
         return event_or_raw_event if event_or_raw_event.is_a?(EventStoreClient::DeserializedEvent)
 
-        Serializer::EventDeserializer.call(event_or_raw_event, serializer: serializer)
+        Serializer::EventDeserializer.call(
+          event_or_raw_event, config: config, serializer: serializer
+        )
       end
     end
   end

data/lib/event_store_client/mapper/encrypted.rb

@@ -8,20 +8,21 @@ require 'event_store_client/data_decryptor'
 
 module EventStoreClient
   module Mapper
-    ##
     # Transforms given event's data and encrypts/decrypts selected subset of data
     # based on encryption schema stored in the event itself.
     class Encrypted
       MissingEncryptionKey = Class.new(StandardError)
 
-      attr_reader :key_repository, :serializer
-      private :key_repository, :serializer
+      attr_reader :key_repository, :serializer, :config
+      private :key_repository, :serializer, :config
 
       # @param key_repository [#find, #create, #encrypt, #decrypt]
       #   See spec/support/dummy_repository.rb for the example of simple in-memory implementation
+      # @param config [EventStoreClient::Config]
       # @param serializer [#serialize, #deserialize]
-      def initialize(key_repository, serializer: Serializer::Json)
+      def initialize(key_repository, config:, serializer: Serializer::Json)
         @key_repository = key_repository
+        @config = config
         @serializer = serializer
       end
 
@@ -29,7 +30,7 @@ module EventStoreClient
       # @return [Hash]
       def serialize(event)
         # Links don't need to be encrypted
-        return Default.new(serializer: serializer).serialize(event) if event.link?
+        return Default.new(serializer: serializer, config: config).serialize(event) if event.link?
 
         serialized = Serializer::EventSerializer.call(event, serializer: serializer)
         encryption_schema =
@@ -54,14 +55,16 @@ module EventStoreClient
       # @return event [EventStoreClient::DeserializedEvent]
       def deserialize(event_or_raw_event, skip_decryption: false)
         if skip_decryption
-          return Default.new(serializer: serializer).deserialize(event_or_raw_event)
+          return Default.new(serializer: serializer, config: config).deserialize(event_or_raw_event)
         end
 
         event =
           if event_or_raw_event.is_a?(EventStoreClient::DeserializedEvent)
             event_or_raw_event
           else
-            Serializer::EventDeserializer.call(event_or_raw_event, serializer: serializer)
+            Serializer::EventDeserializer.call(
+              event_or_raw_event, config: config, serializer: serializer
+            )
           end
 
         decrypted_data =

data/lib/event_store_client/serializer/event_deserializer.rb

@@ -8,18 +8,20 @@ module EventStoreClient
       class << self
         # @param raw_event [EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent, EventStore::Client::PersistentSubscriptions::ReadResp::ReadEvent::RecordedEvent]
         # @param serializer [#serialize, #deserialize]
+        # @param config [EventStoreClient::Config]
         # @return [EventStoreClient::DeserializedEvent]
-        def call(raw_event, serializer: Serializer::Json)
-          new(serializer: serializer).call(raw_event)
+        def call(raw_event, config:, serializer: Serializer::Json)
+          new(config: config, serializer: serializer).call(raw_event)
         end
       end
 
-      attr_reader :serializer
-      private :serializer
+      attr_reader :serializer, :config
+      private :serializer, :config
 
       # @param serializer [#serialize, #deserialize]
-      def initialize(serializer:)
+      def initialize(serializer:, config:)
         @serializer = serializer
+        @config = config
       end
 
       # @param raw_event [EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent, EventStore::Client::PersistentSubscriptions::ReadResp::ReadEvent::RecordedEvent]
@@ -64,10 +66,6 @@ module EventStoreClient
 
         raw_data
       end
-
-      def config
-        EventStoreClient.config
-      end
     end
   end
 end

data/lib/event_store_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EventStoreClient
-  VERSION = '2.1.5'
+  VERSION = '2.3.0-beta'
 end

data/lib/event_store_client.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-module EventStoreClient
-end
-
 require 'json'
 require 'set'
 
@@ -18,8 +15,52 @@ require 'event_store_client/connection/url'
 require 'event_store_client/connection/url_parser'
 require 'event_store_client/deserialized_event'
 require 'event_store_client/serialized_event'
-require 'event_store_client/configuration'
+require 'event_store_client/config'
 
 require 'event_store_client/mapper'
 
 require 'event_store_client/adapters/grpc'
+
+module EventStoreClient
+  class << self
+    # @param name [Symbol, String]
+    def configure(name: :default)
+      yield(config(name)) if block_given?
+    end
+
+    # @param name [Symbol, String]
+    # @return [EventStore::Config]
+    def config(name = :default)
+      @config[name] ||= Config.new(name: name)
+    end
+
+    # @param config_name [Symbol, String]
+    # @return [EventStore::GRPC::Client]
+    def client(config_name: :default)
+      GRPC::Client.new(_config(config_name))
+    end
+
+    # @return [void]
+    def init_default_config
+      @config = { default: Config.new }
+    end
+
+    private
+
+    # @param config [Symbol, String]
+    # @return [EventStoreClient::Config]
+    # @raise [RuntimeError]
+    def _config(config)
+      return @config[config] if @config[config]
+
+      error_message = <<~TEXT
+        Could not find #{config.inspect} config. You can define it in next way:
+        EventStoreClient.configure(name: #{config.inspect}) do |config|
+          # your config goes here
+        end
+      TEXT
+      raise error_message
+    end
+  end
+  init_default_config
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_store_client
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.3.0.pre.beta
 platform: ruby
 authors:
 - Sebastian Wilgosz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-05 00:00:00.000000000 Z
+date: 2022-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -214,7 +214,7 @@ files:
 - lib/event_store_client/adapters/grpc/shared/options/stream_options.rb
 - lib/event_store_client/adapters/grpc/shared/streams/process_response.rb
 - lib/event_store_client/adapters/grpc/shared/streams/process_responses.rb
-- lib/event_store_client/configuration.rb
+- lib/event_store_client/config.rb
 - lib/event_store_client/connection/url.rb
 - lib/event_store_client/connection/url_parser.rb
 - lib/event_store_client/data_decryptor.rb
@@ -247,9 +247,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key: 

data/lib/event_store_client/configuration.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class Config
-    include Extensions::OptionsExtension
-
-    option(:eventstore_url) { 'esdb://localhost:2113' }
-    option(:per_page) { 20 }
-    option(:mapper) { Mapper::Default.new }
-    option(:default_event_class) { DeserializedEvent }
-    option(:logger)
-    option(:skip_deserialization) { false }
-    option(:skip_decryption) { false }
-
-    def eventstore_url=(value)
-      @eventstore_url =
-        if value.is_a?(Connection::Url)
-          value
-        else
-          Connection::UrlParser.new.call(value)
-        end
-    end
-
-    # @param logger [Logger, nil]
-    # @return [Logger, nil]
-    def logger=(logger)
-      ::GRPC.define_singleton_method :logger do
-        @logger ||= logger.nil? ? ::GRPC::DefaultLogger::NoopLogger.new : logger
-      end
-      @logger = logger
-    end
-  end
-
-  class << self
-    def configure
-      yield(config) if block_given?
-    end
-
-    def config
-      @config ||= Config.new
-    end
-
-    def client
-      GRPC::Client.new
-    end
-  end
-
-  # Configuration module to be included in classes required configured variables
-  # Usage: include EventStore::Configuration
-  # config.eventstore_url
-  #
-  module Configuration
-    # An instance of the EventStoreClient's configuration
-    #
-    def config
-      EventStoreClient.config
-    end
-  end
-end