statelydb 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a723737fdce6e8ad2bec8937cfd79f6d968df0fc3e9e747c64e18af9ce769601
-  data.tar.gz: 1f0279a8b9507f4cffacc360ab82e2289471a40de39bd3891f0c7db5c63877c6
+  metadata.gz: f1d7563d7f40d84bdc1ef3dacff41707ed1d915b638223d33b488ca4c7de531f
+  data.tar.gz: dd682b92fbc100505e15820c5415acadc9defc6bc2f2d0dad5b5797deddbf24b
 SHA512:
-  metadata.gz: 815835070a91366b18948afe145eb548ae4f6ecbc6559ed3b8193288cd1084b7ac1a416264b0769afea93f4a8c01e17b0474facb46fe90460b0b3db803466428
-  data.tar.gz: e0c75f31911432f2544c4097fbc0c7a1615624257e80495aef9e5b3a0dddc92dd9341683d24416c4a32ab19b8bd34a2d79abb577781d75ee41b55a02f2e2e11c
+  metadata.gz: c0f27aa770fdf0c7b3386ac37862226cb4b5215766d265e47c82323b2157966e6ce0d87b5e4081d8d9dcd549f45cd0f6527203b0025b0e6c62ce0780c81dae74
+  data.tar.gz: de86db0a2a0227e6bec231d11c378bffff42fa7911ccc0874bd3ed97fae7f73d0ac29ce55b31817f75bfa82c0b63daa79dabd28276a66e17e2748770450f6243

data/lib/common/auth/auth_token_provider.rb

@@ -30,16 +30,19 @@ module StatelyDB
         # @param [String] client_secret The StatelyDB client secret credential
         # @param [String] client_id The StatelyDB client ID credential
         # @param [String] access_key The StatelyDB access key credential
+        # @param [Float] base_retry_backoff_secs The base retry backoff in seconds
         def initialize(
           origin: "https://oauth.stately.cloud",
           audience: "api.stately.cloud",
           client_secret: ENV.fetch("STATELY_CLIENT_SECRET", nil),
           client_id: ENV.fetch("STATELY_CLIENT_ID", nil),
-          access_key: ENV.fetch("STATELY_ACCESS_KEY", nil)
+          access_key: ENV.fetch("STATELY_ACCESS_KEY", nil),
+          base_retry_backoff_secs: 1
         )
           super()
           @actor = Async::Actor.new(Actor.new(origin: origin, audience: audience,
-                                              client_secret: client_secret, client_id: client_id, access_key: access_key))
+                                              client_secret: client_secret, client_id: client_id, access_key: access_key,
+                                              base_retry_backoff_secs: base_retry_backoff_secs))
           # 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
@@ -64,18 +67,23 @@ module StatelyDB
           # @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
+          # @param [String] access_key The StatelyDB access key credential
+          # @param [Float] base_retry_backoff_secs The base retry backoff in seconds
           def initialize(
             origin:,
             audience:,
             client_secret:,
             client_id:,
-            access_key:
+            access_key:,
+            base_retry_backoff_secs:
           )
             super()
 
             @token_fetcher = nil
             if !access_key.nil?
-              @token_fetcher = StatelyDB::Common::Auth::StatelyAccessTokenFetcher.new(origin: origin, access_key: access_key)
+              @token_fetcher = StatelyDB::Common::Auth::StatelyAccessTokenFetcher.new(
+                origin: origin, access_key: access_key, base_retry_backoff_secs: base_retry_backoff_secs
+              )
             elsif !client_secret.nil? && !client_id.nil?
               @token_fetcher = StatelyDB::Common::Auth::Auth0TokenFetcher.new(origin: origin, audience: audience,
                                                                               client_secret: client_secret, client_id: client_id)

data/lib/common/auth/token_fetcher.rb

@@ -58,8 +58,6 @@ module StatelyDB
           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
 
@@ -77,11 +75,22 @@ module StatelyDB
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < TokenFetcher
+        NON_RETRYABLE_ERRORS = [
+          GRPC::Core::StatusCodes::UNAUTHENTICATED,
+          GRPC::Core::StatusCodes::PERMISSION_DENIED,
+          GRPC::Core::StatusCodes::NOT_FOUND,
+          GRPC::Core::StatusCodes::UNIMPLEMENTED,
+          GRPC::Core::StatusCodes::INVALID_ARGUMENT
+        ].freeze
+        RETRY_ATTEMPTS = 10
+
         # @param [String] origin The origin of the OAuth server
         # @param [String] access_key The StatelyDB access key credential
-        def initialize(origin:, access_key:)
+        # @param [Float] base_retry_backoff_secs The base backoff time in seconds
+        def initialize(origin:, access_key:, base_retry_backoff_secs:)
           super()
           @access_key = access_key
+          @base_retry_backoff_secs = base_retry_backoff_secs
           @channel = Common::Net.new_channel(endpoint: origin)
           error_interceptor = Common::ErrorInterceptor.new
           @stub = Stately::Auth::AuthService::Stub.new(nil, nil, channel_override: @channel,
@@ -91,14 +100,45 @@ module StatelyDB
         # Fetch a new token from the StatelyDB API
         # @return [TokenResult] The fetched TokenResult
         def fetch
-          resp = @stub.get_auth_token(Stately::Auth::GetAuthTokenRequest.new(access_key: @access_key))
-          TokenResult.new(token: resp.auth_token, expires_in_secs: resp.expires_in_s)
+          RETRY_ATTEMPTS.times do |i|
+            resp = @stub.get_auth_token(Stately::Auth::GetAuthTokenRequest.new(access_key: @access_key))
+            return TokenResult.new(token: resp.auth_token, expires_in_secs: resp.expires_in_s)
+          rescue StatelyDB::Error => e
+            # raise if it's the final attempt or if the error is not retryable
+            raise e unless self.class.retryable_error?(e) && i < RETRY_ATTEMPTS - 1
+
+            # exponential backoff
+            sleep(backoff(i, @base_retry_backoff_secs))
+          end
         end
 
         def close
           @channel&.close
         end
+
+        # Check if an error is retryable
+        # @param [StatelyDB::Error] err The error to check
+        # @return [Boolean] True if the error is retryable
+        def self.retryable_error?(err)
+          !NON_RETRYABLE_ERRORS.include?(err.code)
+        end
       end
     end
   end
 end
+
+# backoff returns a duration to wait before retrying a request. `attempt` is
+# the current attempt number, starting from 0 (e.g. the first attempt is 0,
+# then 1, then 2...).
+#
+# @param [Integer] attempt The current attempt number
+# @param [Float] base_backoff The base backoff time in seconds
+# @return [Float] The duration in seconds to wait before retrying
+def backoff(attempt, base_backoff)
+  # Double the base backoff time per attempt, starting with 1
+  exp = 2**attempt
+  # Add a full jitter to the backoff time, from no wait to 100% of the exponential backoff.
+  # See https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+  jitter = rand
+  (exp * jitter * base_backoff)
+end

data/sig/statelydb.rbi

@@ -636,11 +636,22 @@ module StatelyDB
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < StatelyDB::Common::Auth::TokenFetcher
+        NON_RETRYABLE_ERRORS = T.let([
+  GRPC::Core::StatusCodes::UNAUTHENTICATED,
+  GRPC::Core::StatusCodes::PERMISSION_DENIED,
+  GRPC::Core::StatusCodes::NOT_FOUND,
+  GRPC::Core::StatusCodes::UNIMPLEMENTED,
+  GRPC::Core::StatusCodes::INVALID_ARGUMENT
+].freeze, T.untyped)
+        RETRY_ATTEMPTS = T.let(10, T.untyped)
+
         # _@param_ `origin` — The origin of the OAuth server
         # 
         # _@param_ `access_key` — The StatelyDB access key credential
-        sig { params(origin: String, access_key: String).void }
-        def initialize(origin:, access_key:); end
+        # 
+        # _@param_ `base_retry_backoff_secs` — The base backoff time in seconds
+        sig { params(origin: String, access_key: String, base_retry_backoff_secs: Float).void }
+        def initialize(origin:, access_key:, base_retry_backoff_secs:); end
 
         # Fetch a new token from the StatelyDB API
         # 
@@ -650,6 +661,14 @@ module StatelyDB
 
         sig { returns(T.untyped) }
         def close; end
+
+        # Check if an error is retryable
+        # 
+        # _@param_ `err` — The error to check
+        # 
+        # _@return_ — True if the error is retryable
+        sig { params(err: StatelyDB::Error).returns(T::Boolean) }
+        def self.retryable_error?(err); end
       end
 
       # TokenProvider is an abstract base class that should be extended
@@ -682,16 +701,19 @@ module StatelyDB
         # _@param_ `client_id` — The StatelyDB client ID credential
         # 
         # _@param_ `access_key` — The StatelyDB access key credential
+        # 
+        # _@param_ `base_retry_backoff_secs` — The base retry backoff in seconds
         sig do
           params(
             origin: String,
             audience: String,
             client_secret: String,
             client_id: String,
-            access_key: String
+            access_key: String,
+            base_retry_backoff_secs: Float
           ).void
         end
-        def initialize(origin: "https://oauth.stately.cloud", audience: "api.stately.cloud", client_secret: ENV.fetch("STATELY_CLIENT_SECRET", nil), client_id: ENV.fetch("STATELY_CLIENT_ID", nil), access_key: ENV.fetch("STATELY_ACCESS_KEY", nil)); end
+        def initialize(origin: "https://oauth.stately.cloud", audience: "api.stately.cloud", client_secret: ENV.fetch("STATELY_CLIENT_SECRET", nil), client_id: ENV.fetch("STATELY_CLIENT_ID", nil), access_key: ENV.fetch("STATELY_ACCESS_KEY", nil), base_retry_backoff_secs: 1); end
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
@@ -714,16 +736,21 @@ module StatelyDB
           # _@param_ `client_secret` — The StatelyDB client secret credential
           # 
           # _@param_ `client_id` — The StatelyDB client ID credential
+          # 
+          # _@param_ `access_key` — The StatelyDB access key credential
+          # 
+          # _@param_ `base_retry_backoff_secs` — The base retry backoff in seconds
           sig do
             params(
               origin: String,
               audience: String,
               client_secret: String,
               client_id: String,
-              access_key: T.untyped
+              access_key: String,
+              base_retry_backoff_secs: Float
             ).void
           end
-          def initialize(origin:, audience:, client_secret:, client_id:, access_key:); end
+          def initialize(origin:, audience:, client_secret:, client_id:, access_key:, base_retry_backoff_secs:); end
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.

data/sig/statelydb.rbs

@@ -550,10 +550,15 @@ module StatelyDB
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < StatelyDB::Common::Auth::TokenFetcher
+        NON_RETRYABLE_ERRORS: untyped
+        RETRY_ATTEMPTS: untyped
+
         # _@param_ `origin` — The origin of the OAuth server
         # 
         # _@param_ `access_key` — The StatelyDB access key credential
-        def initialize: (origin: String, access_key: String) -> void
+        # 
+        # _@param_ `base_retry_backoff_secs` — The base backoff time in seconds
+        def initialize: (origin: String, access_key: String, base_retry_backoff_secs: Float) -> void
 
         # Fetch a new token from the StatelyDB API
         # 
@@ -561,6 +566,13 @@ module StatelyDB
         def fetch: () -> TokenResult
 
         def close: () -> untyped
+
+        # Check if an error is retryable
+        # 
+        # _@param_ `err` — The error to check
+        # 
+        # _@return_ — True if the error is retryable
+        def self.retryable_error?: (StatelyDB::Error err) -> bool
       end
 
       # TokenProvider is an abstract base class that should be extended
@@ -591,12 +603,15 @@ module StatelyDB
         # _@param_ `client_id` — The StatelyDB client ID credential
         # 
         # _@param_ `access_key` — The StatelyDB access key credential
+        # 
+        # _@param_ `base_retry_backoff_secs` — The base retry backoff in seconds
         def initialize: (
                           ?origin: String,
                           ?audience: String,
                           ?client_secret: String,
                           ?client_id: String,
-                          ?access_key: String
+                          ?access_key: String,
+                          ?base_retry_backoff_secs: Float
                         ) -> void
 
         # Close the token provider and kill any background operations
@@ -618,12 +633,17 @@ module StatelyDB
           # _@param_ `client_secret` — The StatelyDB client secret credential
           # 
           # _@param_ `client_id` — The StatelyDB client ID credential
+          # 
+          # _@param_ `access_key` — The StatelyDB access key credential
+          # 
+          # _@param_ `base_retry_backoff_secs` — The base retry backoff in seconds
           def initialize: (
                             origin: String,
                             audience: String,
                             client_secret: String,
                             client_id: String,
-                            access_key: untyped
+                            access_key: String,
+                            base_retry_backoff_secs: Float
                           ) -> void
 
           # Initialize the actor. This runs on the actor thread which means

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Stately Cloud, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-12 00:00:00.000000000 Z
+date: 2024-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async