statelydb 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '039f735f87b49d58192914fdb0ff62cafce5d059980628671854026864248223'
-  data.tar.gz: 0ee06ba443aae408cb3a25d98041560a48f1ac6ddfd2ef9f25f13b62c21ee34c
+  metadata.gz: 14c7769c562abe9ba0294a0d3ec4a1c7a620f9233f35209d39766331f3dd73e5
+  data.tar.gz: db2562de5584684ef9baf9de405b38112a43eb123aa3826ae4e563c6cfa0c1d0
 SHA512:
-  metadata.gz: 83ef6dd4a7fc6c98d3668ac42544d568105d78421a7c2bc8d0d56e588b4a39eac823473f2e8e797bb339c6c04459bfc39a07457cadf21590d5d90036ff808e61
-  data.tar.gz: ff67b6ef6513ebe45df1ad0c12ca8d1906cee183e830a3d303d4cd6eda47e2bbf6a22634a55057ece224b13f473df23ad428f324c52806ab7904d76cb47ef159
+  metadata.gz: 4ba09f8776771bb4b6fc078e32255a272d986e6983737e1df9fe71bf95e685484ce6d20a91f16c96973bc89f7c9c79d1c0b9411f4a683430581bbc1e27a17468
+  data.tar.gz: cf612cf68f6c714ba7e79d328ab2b18236c711dbe806a6fb9714dd93eb163ac9899a415bb6c5d4861d24f103bc3844dff40cde27c4eca37eecf1ac3304298f93

data/lib/api/db/put_pb.rb

@@ -7,7 +7,7 @@ require 'google/protobuf'
 require 'db/item_pb'
 
 
-descriptor_data = "\n\x0c\x64\x62/put.proto\x12\nstately.db\x1a\rdb/item.proto\"|\n\nPutRequest\x12\x19\n\x08store_id\x18\x01 \x01(\x04R\x07storeId\x12\'\n\x04puts\x18\x02 \x03(\x0b\x32\x13.stately.db.PutItemR\x04puts\x12*\n\x11schema_version_id\x18\x03 \x01(\rR\x0fschemaVersionId\"/\n\x07PutItem\x12$\n\x04item\x18\x01 \x01(\x0b\x32\x10.stately.db.ItemR\x04item\"5\n\x0bPutResponse\x12&\n\x05items\x18\x01 \x03(\x0b\x32\x10.stately.db.ItemR\x05itemsBc\n\x0e\x63om.stately.dbB\x08PutProtoP\x01\xa2\x02\x03SDX\xaa\x02\nStately.Db\xca\x02\nStately\\Db\xe2\x02\x16Stately\\Db\\GPBMetadata\xea\x02\x0bStately::Dbb\x06proto3"
+descriptor_data = "\n\x0c\x64\x62/put.proto\x12\nstately.db\x1a\rdb/item.proto\"|\n\nPutRequest\x12\x19\n\x08store_id\x18\x01 \x01(\x04R\x07storeId\x12\'\n\x04puts\x18\x02 \x03(\x0b\x32\x13.stately.db.PutItemR\x04puts\x12*\n\x11schema_version_id\x18\x03 \x01(\rR\x0fschemaVersionId\"U\n\x07PutItem\x12$\n\x04item\x18\x01 \x01(\x0b\x32\x10.stately.db.ItemR\x04item\x12$\n\x0emust_not_exist\x18\x03 \x01(\x08R\x0cmustNotExist\"5\n\x0bPutResponse\x12&\n\x05items\x18\x01 \x03(\x0b\x32\x10.stately.db.ItemR\x05itemsBc\n\x0e\x63om.stately.dbB\x08PutProtoP\x01\xa2\x02\x03SDX\xaa\x02\nStately.Db\xca\x02\nStately\\Db\xe2\x02\x16Stately\\Db\\GPBMetadata\xea\x02\x0bStately::Dbb\x06proto3"
 
 pool = Google::Protobuf::DescriptorPool.generated_pool
 pool.add_serialized_file(descriptor_data)

data/lib/api/db/service_services_pb.rb

@@ -35,7 +35,7 @@ module Stately
         rpc :Get, ::Stately::Db::GetRequest, ::Stately::Db::GetResponse
         # Delete removes one or more Items from the Store by their key paths. This
         # will fail if the caller does not have permission to delete Items.
-        # Tombstones will be saved for deleted items for  time, so
+        # Tombstones will be saved for deleted items for some time, so
         # that SyncList can return information about deleted items. Deletes are
         # always applied atomically; all will fail or all will succeed.
         rpc :Delete, ::Stately::Db::DeleteRequest, ::Stately::Db::DeleteResponse

data/lib/common/auth/auth0_token_provider.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "async"
+require "async/actor"
 require "async/http/internet"
 require "async/semaphore"
 require "json"
@@ -12,6 +13,7 @@ LOGGER = Logger.new($stdout)
 LOGGER.level = Logger::WARN
 DEFAULT_GRANT_TYPE = "client_credentials"
 
+# A module for Stately Cloud auth code
 module StatelyDB
   module Common
     # A module for Stately Cloud auth code
@@ -21,102 +23,183 @@ module StatelyDB
       # It will default to using the values of `STATELY_CLIENT_ID` and `STATELY_CLIENT_SECRET` if
       # no credentials are explicitly passed and will throw an error if none are found.
       class Auth0TokenProvider < TokenProvider
-        # @param [String] auth_url The URL of the OAuth server
+        # @param [Endpoint] domain The domain of the OAuth server
         # @param [String] audience The OAuth Audience for the token
         # @param [String] client_secret The StatelyDB client secret credential
         # @param [String] client_id The StatelyDB client ID credential
         def initialize(
-          auth_url: "https://oauth.stately.cloud",
+          domain: "https://oauth.stately.cloud",
           audience: "api.stately.cloud",
           client_secret: ENV.fetch("STATELY_CLIENT_SECRET"),
           client_id: ENV.fetch("STATELY_CLIENT_ID")
         )
           super()
-          @client_id = client_id
-          @client_secret = client_secret
-          @audience = audience
-          @auth_url = "#{auth_url}/oauth/token"
-          @access_token = nil
-          @pending_refresh = nil
-          @timer = nil
-
-          Async do |_task|
-            refresh_token
-          end
-
-          # need a weak ref to ourself or the GC will never run the finalizer
-          ObjectSpace.define_finalizer(WeakRef.new(self), finalize)
+          @actor = Async::Actor.new(Actor.new(domain: domain, audience: audience, client_secret: client_secret,
+                                              client_id: client_id))
+          # this initialization cannot happen in the constructor because it is async and must run on the event loop
+          # which is not available in the constructor
+          @actor.init
         end
 
-        # finalizer kills the thread running the timer if one exists
-        # @return [Proc] The finalizer proc
-        def finalize
-          proc {
-            Thread.kill(@timer) unless @timer.nil?
-          }
+        # Close the token provider and kill any background operations
+        # This just invokes the close method on the actor which should do the cleanup
+        def close
+          @actor.close
         end
 
         # Get the current access token
         # @return [String] The current access token
-        def access_token
-          # TODO: - check whether or not the GIL is enough to make this threadsafe
-          @access_token || refresh_token
+        def get_token(force: false)
+          @actor.get_token(force: force)
         end
 
-        private
-
-        # Refresh the access token
-        # @return [void]
-        def refresh_token
-          # never run more than one at a time.
-          @pending_refresh ||= refresh_token_impl
-          # many threads all wait on the same task here.
-          # I wrote a test to check this is possible
-          @pending_refresh.wait
-          # multiple people will all set this to nil after
-          # they are done waiting but I don't think i can put this inside
-          # refresh_token_impl. It seems harmless because of the GIL?
-          @pending_refresh = nil
-        end
+        # Actor for managing the token refresh
+        # This is designed to be used with Async::Actor and run on a dedicated thread.
+        class Actor
+          # @param [Endpoint] domain The domain of the OAuth server
+          # @param [String] audience The OAuth Audience for the token
+          # @param [String] client_secret The StatelyDB client secret credential
+          # @param [String] client_id The StatelyDB client ID credential
+          def initialize(
+            domain: "https://oauth.stately.cloud",
+            audience: "api.stately.cloud",
+            client_secret: ENV.fetch("STATELY_CLIENT_SECRET"),
+            client_id: ENV.fetch("STATELY_CLIENT_ID")
+          )
+            super()
+            @client = Async::HTTP::Client.new(Async::HTTP::Endpoint.parse(domain))
+            @client_id = client_id
+            @client_secret = client_secret
+            @audience = audience
 
-        # Refresh the access token implementation
-        # @return [String] The new access token
-        def refresh_token_impl
-          Async do
-            client = Async::HTTP::Internet.new
-            headers = [["content-type", "application/json"]]
-            data = { "client_id" => @client_id, client_secret: @client_secret, audience: @audience,
-                     grant_type: DEFAULT_GRANT_TYPE }
-            body = [JSON.dump(data)]
-
-            resp = client.post(@auth_url, headers, body)
-            resp_data = JSON.parse(resp.read)
-            raise "Auth request failed: #{resp_data}" if resp.status != 200
-
-            @access_token = resp_data["access_token"]
-
-            # do this on a thread or else the sleep
-            # will block the event loop.
-            # there is no non-blocking sleep in ruby.
-            # skip this if we have a pending timer thread already
-            @timer = Thread.new do
-              # Calculate a random multiplier between 0.3 and 0.8 to to apply to the expiry
+            @access_token = nil
+            @expires_at_secs = nil
+            @pending_refresh = nil
+          end
+
+          # Initialize the actor. This runs on the actor thread which means
+          # we can dispatch async operations here.
+          def init
+            refresh_token
+          end
+
+          # Close the token provider and kill any background operations
+          def close
+            @scheduled&.stop
+            @client&.close
+          end
+
+          # Get the current access token
+          # @param [Boolean] force Whether to force a refresh of the token
+          # @return [String] The current access token
+          def get_token(force: false)
+            if force
+              @access_token = nil
+              @expires_at_secs = nil
+            else
+              token, ok = valid_access_token
+              return token if ok
+            end
+
+            refresh_token.wait
+          end
+
+          # Get the current access token and whether it is valid
+          # @return [Array] The current access token and whether it is valid
+          def valid_access_token
+            return "", false if @access_token.nil?
+            return "", false if @expires_at_secs.nil?
+            return "", false if @expires_at_secs < Time.now.to_i
+
+            [@access_token, true]
+          end
+
+          # Refresh the access token
+          # @return [string] The new access token
+          def refresh_token
+            Async do
+              # we use an Async::Condition to dedupe multiple requests here
+              # if the condition exists, we wait on it to complete
+              # otherwise we create a condition, make the request, then signal the condition with the result
+              # If there is an error then we signal that instead so we can raise it for the waiters.
+              if @pending_refresh.nil?
+                begin
+                  @pending_refresh = Async::Condition.new
+                  new_access_token = refresh_token_impl.wait
+                  # now broadcast the new token to any waiters
+                  @pending_refresh.signal(new_access_token)
+                  new_access_token
+                rescue StandardError => e
+                  @pending_refresh.signal(e)
+                  raise e
+                ensure
+                  # delete the condition to restart the process
+                  @pending_refresh = nil
+                end
+              else
+                res = @pending_refresh.wait
+                # if the refresh result is an error, re-raise it.
+                # otherwise return the token
+                raise res if res.is_a?(StandardError)
+
+                res
+              end
+            end
+          end
+
+          # Refresh the access token implementation
+          # @return [String] The new access token
+          def refresh_token_impl
+            Async do
+              resp_data = make_auth0_request
+
+              new_access_token = resp_data["access_token"]
+              new_expires_in_secs = resp_data["expires_in"]
+              new_expires_at_secs = Time.now.to_i + new_expires_in_secs
+              if @expires_at_secs.nil? || new_expires_at_secs > @expires_at_secs
+
+                @access_token = new_access_token
+                @expires_at_secs = new_expires_at_secs
+              else
+
+                new_access_token = @access_token
+                new_expires_in_secs = @expires_at_secs - Time.now.to_i
+              end
+
+              # Schedule a refresh of the token ahead of the expiry time
+              # Calculate a random multiplier between 0.9 and 0.95 to to apply to the expiry
               # so that we refresh in the background ahead of expiration, but avoid
               # multiple processes hammering the service at the same time.
-              jitter = (Random.rand * 0.5) + 0.3
-              delay = resp_data["expires_in"] * jitter
-              sleep(delay)
-              refresh_token
+              jitter = (Random.rand * 0.05) + 0.9
+              delay_secs = new_expires_in_secs * jitter
+
+              # do this on the fiber scheduler (the root scheduler) to avoid infinite recursion
+              @scheduled ||= Fiber.scheduler.async do
+                # Kernel.sleep is non-blocking if Ruby 3.1+ and Async 2+
+                # https://github.com/socketry/async/issues/305#issuecomment-1945188193
+                sleep(delay_secs)
+                refresh_token
+                @scheduled = nil
+              end
+
+              new_access_token
+            end
+          end
+
+          def make_auth0_request
+            headers = [["content-type", "application/json"]]
+            body = JSON.dump({ "client_id" => @client_id, client_secret: @client_secret, audience: @audience,
+                               grant_type: DEFAULT_GRANT_TYPE })
+            Sync do
+              # TODO: Wrap this in a retry loop and parse errors like we
+              # do in the Go SDK.
+              response = @client.post("/oauth/token", headers, body)
+              raise "Auth request failed" if response.status != 200
+
+              JSON.parse(response.read)
+            ensure
+              response&.close
             end
-            @pending_refresh = nil
-            resp_data["access_token"]
-          rescue StandardError => e
-            # set the token to nil so that it will
-            # be refreshed on the next get
-            @access_token = nil
-            LOGGER.warn(e)
-          ensure
-            client.close
           end
         end
       end

data/lib/common/auth/interceptor.rb

@@ -74,7 +74,7 @@ module StatelyDB
         # @return [void]
         # @api private
         def add_jwt_to_grpc_request(metadata:)
-          metadata["authorization"] = "Bearer #{@token_provider.access_token}"
+          metadata["authorization"] = "Bearer #{@token_provider.get_token}"
         end
       end
     end

data/lib/common/auth/token_provider.rb

@@ -8,8 +8,14 @@ module StatelyDB
       # for individual token provider implementations
       class TokenProvider
         # Get the current access token
+        # @param [Boolean] force Whether to force a refresh of the token
         # @return [String] The current access token
-        def access_token
+        def get_token(force: false) # rubocop:disable Lint/UnusedMethodArgument
+          raise "Not Implemented"
+        end
+
+        # Close the token provider and kill any background operations
+        def close
           raise "Not Implemented"
         end
       end

data/lib/error.rb

@@ -11,10 +11,13 @@ module StatelyDB
   # The Error class contains common StatelyDB error types.
   class Error < StandardError
     # The gRPC/Connect Code for this error.
+    # @return [Integer]
     attr_reader :code
     # The more fine-grained Stately error code, which is a human-readable string.
+    # @return [String]
     attr_reader :stately_code
     # The upstream cause of the error, if available.
+    # @return [Exception]
     attr_reader :cause
 
     # @param [String] message
@@ -53,6 +56,8 @@ module StatelyDB
       new(error.message, code: GRPC::Core::StatusCodes::UNKNOWN, stately_code: "Unknown", cause: error)
     end
 
+    # Turn this error's gRPC status code into a human-readable string. e.g. 3 -> "InvalidArgument"
+    # @return [String]
     def code_string
       self.class.grpc_code_to_string(@code)
     end

data/lib/statelydb.rb

@@ -38,20 +38,36 @@ module StatelyDB
                    token_provider: Common::Auth::Auth0TokenProvider.new,
                    endpoint: nil,
                    region: nil)
+      if store_id.nil?
+        raise StatelyDB::Error.new("store_id is required",
+                                   code: GRPC::Core::StatusCodes::INVALID_ARGUMENT,
+                                   stately_code: "InvalidArgument")
+      end
+      if schema.nil?
+        raise StatelyDB::Error.new("schema is required",
+                                   code: GRPC::Core::StatusCodes::INVALID_ARGUMENT,
+                                   stately_code: "InvalidArgument")
+      end
 
       endpoint = self.class.make_endpoint(endpoint:, region:)
-      channel = Common::Net.new_channel(endpoint:)
+      @channel = Common::Net.new_channel(endpoint:)
+      @token_provider = token_provider
 
       auth_interceptor = Common::Auth::Interceptor.new(token_provider:)
       error_interceptor = Common::ErrorInterceptor.new
 
-      @stub = Stately::Db::DatabaseService::Stub.new(nil, nil, channel_override: channel,
+      @stub = Stately::Db::DatabaseService::Stub.new(nil, nil, channel_override: @channel,
                                                                interceptors: [error_interceptor, auth_interceptor])
       @store_id = store_id.to_i
       @schema = schema
       @allow_stale = false
     end
 
+    def close
+      @channel&.close
+      @token_provider&.close
+    end
+
     # Set whether to allow stale results for all operations with this client. This produces a new client
     # with the allow_stale flag set.
     # @param allow_stale [Boolean] whether to allow stale results
@@ -169,12 +185,19 @@ module StatelyDB
     # Put an Item into a StatelyDB Store at the given key_path.
     #
     # @param item [StatelyDB::Item] a StatelyDB Item
+    # @param must_not_exist [Boolean] A condition that indicates this item must
+    #   not already exist at any of its key paths. If there is already an item
+    #   at one of those paths, the Put operation will fail with a
+    #   "ConditionalCheckFailed" error. Note that if the item has an
+    #   `initialValue` field in its key, that initial value will automatically
+    #   be chosen not to conflict with existing items, so this condition only
+    #   applies to key paths that do not contain the `initialValue` field.
     # @return [StatelyDB::Item] the item that was stored
     #
-    # @example
-    #   client.data.put(my_item)
-    def put(item)
-      resp = put_batch(item)
+    # @example client.data.put(my_item)
+    # @example client.data.put(my_item, must_not_exist: true)
+    def put(item, must_not_exist: false)
+      resp = put_batch({ item:, must_not_exist: })
 
       # Always return a single Item.
       resp.first
@@ -182,21 +205,32 @@ module StatelyDB
 
     # Put a batch of up to 50 Items into a StatelyDB Store.
     #
-    # @param items [StatelyDB::Item, Array<StatelyDB::Item>] the items to store. Max 50 items.
+    # @param items [StatelyDB::Item, Array<StatelyDB::Item>] the items to store.
+    # Max 50 items.
     # @return [Array<StatelyDB::Item>] the items that were stored
     #
     # @example
     #   client.data.put_batch(item1, item2)
+    # @example
+    #  client.data.put_batch({ item: item1, must_not_exist: true }, item2)
     def put_batch(*items)
-      items = Array(items).flatten
-      req = Stately::Db::PutRequest.new(
-        store_id: @store_id,
-        schema_version_id: @schema::SCHEMA_VERSION_ID,
-        puts: items.map do |item|
+      puts = Array(items).flatten.map do |input|
+        if input.is_a?(Hash)
+          item = input[:item]
+          Stately::Db::PutItem.new(
+            item: item.send("marshal_stately"),
+            must_not_exist: input[:must_not_exist]
+          )
+        else
           Stately::Db::PutItem.new(
-            item: item.send("marshal_stately")
+            item: input.send("marshal_stately")
           )
         end
+      end
+      req = Stately::Db::PutRequest.new(
+        store_id: @store_id,
+        schema_version_id: @schema::SCHEMA_VERSION_ID,
+        puts:
       )
       resp = @stub.put(req)
 
@@ -208,8 +242,8 @@ module StatelyDB
     # Delete up to 50 Items from a StatelyDB Store at the given key_paths.
     #
     # @param key_paths [String, Array<String>] the paths to the items. Max 50 key paths.
-    # @raise [StatelyDB::Error::InvalidParameters] if the parameters are invalid
-    # @raise [StatelyDB::Error::NotFound] if the item is not found
+    # @raise [StatelyDB::Error] if the parameters are invalid
+    # @raise [StatelyDB::Error] if the item is not found
     # @return [void] nil
     #
     # @example
@@ -230,8 +264,8 @@ module StatelyDB
     # If the block completes successfully, the transaction is committed.
     #
     # @return [StatelyDB::Transaction::Transaction::Result] the result of the transaction
-    # @raise [StatelyDB::Error::InvalidParameters] if the parameters are invalid
-    # @raise [StatelyDB::Error::NotFound] if the item is not found
+    # @raise [StatelyDB::Error] if the parameters are invalid
+    # @raise [StatelyDB::Error] if the item is not found
     # @raise [Exception] if any other exception is raised
     #
     # @example

data/lib/transaction/transaction.rb

@@ -226,6 +226,13 @@ module StatelyDB
       # the item will be returned while inside the transaction block.
       #
       # @param item [StatelyDB::Item] the item to store
+      # @param must_not_exist [Boolean] A condition that indicates this item must
+      #   not already exist at any of its key paths. If there is already an item
+      #   at one of those paths, the Put operation will fail with a
+      #   "ConditionalCheckFailed" error. Note that if the item has an
+      #   `initialValue` field in its key, that initial value will automatically
+      #   be chosen not to conflict with existing items, so this condition only
+      #   applies to key paths that do not contain the `initialValue` field.
       # @return [String, Integer] the id of the item
       #
       # @example
@@ -235,16 +242,18 @@ module StatelyDB
       #  results.puts.each do |result|
       #    puts result.key_path
       #  end
-      def put(item)
-        resp = put_batch(item)
+      def put(item, must_not_exist: false)
+        resp = put_batch({ item:, must_not_exist: })
         resp.first
       end
 
-      # Put a batch of up to 50 Items into a StatelyDB Store. Results are not returned until the transaction is
-      # committed and will be available in the Result object returned by commit. A list of identifiers
-      # for the items will be returned while inside the transaction block.
+      # Put a batch of up to 50 Items into a StatelyDB Store. Results are not
+      # returned until the transaction is committed and will be available in the
+      # Result object returned by commit. A list of identifiers for the items
+      # will be returned while inside the transaction block.
       #
-      # @param items [StatelyDB::Item, Array<StatelyDB::Item>] the items to store. Max 50 items.
+      # @param items [StatelyDB::Item, Array<StatelyDB::Item>] the items to store. Max
+      # 50 items.
       # @return [Array<StatelyDB::UUID, String, Integer, nil>] the ids of the items
       #
       # @example
@@ -255,14 +264,22 @@ module StatelyDB
       #    puts result.key_path
       #  end
       def put_batch(*items)
-        items = Array(items).flatten
+        puts = Array(items).flatten.map do |input|
+          if input.is_a?(Hash)
+            item = input[:item]
+            Stately::Db::PutItem.new(
+              item: item.send("marshal_stately"),
+              must_not_exist: input[:must_not_exist]
+            )
+          else
+            Stately::Db::PutItem.new(
+              item: input.send("marshal_stately")
+            )
+          end
+        end
         req = Stately::Db::TransactionRequest.new(
           put_items: Stately::Db::TransactionPut.new(
-            puts: items.map do |item|
-              Stately::Db::PutItem.new(
-                item: item.send("marshal_stately")
-              )
-            end
+            puts:
           )
         )
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Stately Cloud, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2024-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,28 +16,42 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 2.21.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 2.21.1
+- !ruby/object:Gem::Dependency
+  name: async-actor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: async-http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.64.0
+        version: 0.85.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.64.0
+        version: 0.85.0
 - !ruby/object:Gem::Dependency
   name: grpc
   requirement: !ruby/object:Gem::Requirement