Add 408 timeout error as retryable with idempotency key support

Author: swaroopAkkineniWorkos

lib/workos/client.rb

@@ -146,6 +146,13 @@ def handle_error_response(response:)
           http_status: http_status,
           request_id: response['x-request-id'],
         )
+      when 408
+        raise TimeoutError.new(
+          message: json['message'],
+          http_status: http_status,
+          request_id: response['x-request-id'],
+          retry_after: response['Retry-After'],
+        )
       when 422
         message = json['message']
         code = json['code']
@@ -180,7 +187,7 @@ def handle_error_response(response:)
     private
 
     def retryable_error?(http_status)
-      http_status >= 500 || http_status == 429
+      http_status >= 500 || http_status == 408 || http_status == 429
     end
 
     def calculate_backoff(attempt)
@@ -194,8 +201,9 @@ def calculate_backoff(attempt)
     end
 
     def calculate_retry_delay(attempt, response)
-      # If it's a 429 with Retry-After header, use that
-      if response.code.to_i == 429 && response['Retry-After']
+      # If it's a 408 or 429 with Retry-After header, use that
+      http_status = response.code.to_i
+      if (http_status == 408 || http_status == 429) && response['Retry-After']
         retry_after = response['Retry-After'].to_i
         return retry_after if retry_after.positive?
       end

lib/workos/errors.rb

@@ -50,7 +50,7 @@ def to_s
     end
 
     def retryable?
-      return true if http_status && (http_status >= 500 || http_status == 429)
+      return true if http_status && (http_status >= 500 || http_status == 408)
 
       false
     end

spec/lib/workos/audit_logs_spec.rb

@@ -162,6 +162,48 @@
           expect(call_count).to eq(4)
         end
       end
+
+      context 'with 408 request timeout errors' do
+        before do
+          WorkOS.config.max_retries = 3
+        end
+
+        after do
+          WorkOS.config.max_retries = 0
+        end
+
+        it 'retries with the same idempotency key on 408 timeout errors' do
+          allow(described_class).to receive(:client).and_return(double('client'))
+
+          call_count = 0
+          allow(described_class.client).to receive(:request) do |request|
+            call_count += 1
+            expect(request['Idempotency-Key']).to eq('test-idempotency-key')
+
+            if call_count < 2
+              # Return 408 Request Timeout for first attempt
+              response = double('response', code: '408', body: '{"message": "Request Timeout"}')
+              allow(response).to receive(:[]).with('x-request-id').and_return('test-request-id')
+              allow(response).to receive(:[]).with('Retry-After').and_return(nil)
+              response
+            else
+              # Success on 2nd attempt
+              double('response', code: '201', body: '{}')
+            end
+          end
+
+          expect(described_class).to receive(:sleep).once
+
+          response = described_class.create_event(
+            organization: 'org_123',
+            event: valid_event,
+            idempotency_key: 'test-idempotency-key',
+          )
+
+          expect(response.code).to eq('201')
+          expect(call_count).to eq(2)
+        end
+      end
     end
   end
 

spec/lib/workos/client_retry_spec.rb

@@ -57,28 +57,28 @@ def self.test_request
       end
     end
 
-    context 'with 429 errors' do
+    context 'with 408 errors' do
       it 'retries with exponential backoff' do
         allow(test_module).to receive(:client).and_return(double('client'))
         allow(test_module.client).to receive(:request) do
-          double('response', code: '429', body: '{"message": "Rate Limit Exceeded"}', '[]': nil)
+          double('response', code: '408', body: '{"message": "Request Timeout"}', '[]': nil)
         end
 
         expect(test_module.client).to receive(:request).exactly(4).times
         expect(test_module).to receive(:sleep).exactly(3).times
 
         expect do
           test_module.test_request
-        end.to raise_error(WorkOS::RateLimitExceededError)
+        end.to raise_error(WorkOS::TimeoutError)
       end
 
       it 'respects Retry-After header' do
         allow(test_module).to receive(:client).and_return(double('client'))
 
         response_with_retry_after = double(
           'response',
-          code: '429',
-          body: '{"message": "Rate Limit Exceeded"}',
+          code: '408',
+          body: '{"message": "Request Timeout"}',
           '[]': nil,
         )
         allow(response_with_retry_after).to receive(:[]).with('Retry-After').and_return('5')
@@ -89,7 +89,7 @@ def self.test_request
 
         expect do
           test_module.test_request
-        end.to raise_error(WorkOS::RateLimitExceededError)
+        end.to raise_error(WorkOS::TimeoutError)
       end
     end
 
@@ -270,11 +270,15 @@ def self.test_request
       expect(test_module.send(:retryable_error?, 599)).to eq(true)
     end
 
+    it 'returns true for 408 errors' do
+      expect(test_module.send(:retryable_error?, 408)).to eq(true)
+    end
+
     it 'returns true for 429 errors' do
       expect(test_module.send(:retryable_error?, 429)).to eq(true)
     end
 
-    it 'returns false for 4xx errors (except 429)' do
+    it 'returns false for 4xx errors (except 408 and 429)' do
       expect(test_module.send(:retryable_error?, 400)).to eq(false)
       expect(test_module.send(:retryable_error?, 401)).to eq(false)
       expect(test_module.send(:retryable_error?, 404)).to eq(false)