Retries and Caching, Step 1 #167
Conversation
…access token and on verifying said access token fix(platform): Remove unused authorization_backoff_seconds setting refactor(platform): Use proper error messages and logging on failure (of attempts) ro exchange refresh token and verify access token
There was a problem hiding this comment.
Pull Request Overview
This PR implements configurable retry logic for authentication operations to improve robustness when exchanging refresh tokens and verifying JWT tokens. The retry mechanism uses exponential backoff with jitter and distinguishes between retryable errors (server/network issues) and non-retryable errors (client errors).
Key changes:
- Added retry decorators to
_access_token_from_refresh_tokenandverify_and_decode_tokenfunctions with configurable parameters - Replaced generic timeout setting with specific authentication retry configuration parameters
- Enhanced error handling and logging for authentication failures
Reviewed Changes
Copilot reviewed 6 out of 7 changed files in this pull request and generated 1 comment.
Show a summary per file
| File | Description |
|---|---|
src/aignostics/platform/_settings.py |
Replaced request_timeout_seconds and authorization_backoff_seconds with new auth-specific retry configuration parameters |
src/aignostics/platform/_authentication.py |
Added retry logic with tenacity decorators, improved error handling, and introduced JWK client caching |
src/aignostics/platform/_messages.py |
Added specific error messages for token refresh and verification failures |
tests/aignostics/platform/settings_test.py |
Updated tests to reflect new authentication configuration parameter names |
tests/aignostics/platform/authentication_test.py |
Added comprehensive test coverage for retry logic scenarios |
pyproject.toml |
Added tenacity dependency for retry functionality |
| mock_response.status_code = HTTPStatus.UNAUTHORIZED | ||
| mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( | ||
| "Client Error: Unauthorized", response=mock_response |
There was a problem hiding this comment.
The test parameter status_code is not being used. The mock response should use the parameterized status_code value instead of hardcoding HTTPStatus.UNAUTHORIZED.
| mock_response.status_code = HTTPStatus.UNAUTHORIZED | |
| mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( | |
| "Client Error: Unauthorized", response=mock_response | |
| mock_response.status_code = status_code | |
| mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( | |
| f"Client Error: {status_code}", response=mock_response |
…access token and on verifying said access token fix(platform): Remove unused authorization_backoff_seconds setting refactor(platform): Use proper error messages and logging on failure (of attempts) ro exchange refresh token and verify access token
Codecov Report❌ Patch coverage is 📢 Thoughts on this report? Let us know! |
PR Review: Retries for Authentication - Refresh Token Exchange and JWT VerificationSummaryThis PR adds retry logic to authentication flows and removes an unused setting. The implementation is well-thought-out with comprehensive test coverage (323 new test lines). Overall, this is excellent work with intelligent retry strategies that distinguish between transient and permanent failures. ✅ Strengths1. Intelligent Retry Logic
2. PyJWKClient Caching
3. Comprehensive Test Coverage
4. Proper Error Handling
5. Configuration
🔍 Issues & Concerns1. Settings Access in Decorator (Potential Bug)
|
PR Review: Retries for authenticationThis PR adds intelligent retry logic to authentication operations. Overall well-implemented with excellent test coverage. Strengths
Critical Issue: Incorrect Retry LogicLocation: src/aignostics/platform/_authentication.py:478 The retry logic uses regex matching on exception messages but requests.exceptions.HTTPError does not include Client Error by default. This means ALL HTTP errors including 4xx will be retried not just 5xx. The test at line 722 manually injects Client Error which masks this bug in production. Recommendation: Check HTTP status code instead of exception message using a custom predicate function that inspects exception.response.status_code. Other Recommendations
Performance
ConclusionApprove with request to fix the retry logic bug. Great work on comprehensive testing and code quality |
![claude[bot]](https://avatars.githubusercontent.com/in/1236702?s=60&v=4){kind=small}
| RuntimeError: If token exchange fails. Message indicates if "Client Error". | ||
| """ | ||
| retryer = Retrying( # We are not using annotations as settings can change at runtime | ||
| retry=retry_if_exception_message(match=r"^(?!.*Client Error:).*$"), |
There was a problem hiding this comment.
Critical Bug: This regex pattern won't work as intended. requests.exceptions.HTTPError doesn't include "Client Error:" in its string representation by default.
This means all HTTP errors (including 4xx client errors) will be retried, not just 5xx server errors.
Suggested fix:
def _should_retry_token_refresh(exception: BaseException) -> bool:
"""Only retry on server errors (5xx) and network errors, not client errors (4xx)."""
if isinstance(exception, requests.exceptions.HTTPError):
if exception.response is not None:
# Don't retry client errors (4xx) - they won't succeed on retry
return exception.response.status_code >= 500
# Retry connection/timeout errors
return isinstance(exception, (
requests.exceptions.ConnectionError,
requests.exceptions.Timeout,
))
retryer = Retrying(
retry=retry_if_exception(_should_retry_token_refresh),
...
)
| except (HTTPError, requests.exceptions.RequestException) as e: | ||
| raise RuntimeError(AUTHENTICATION_FAILED) from e | ||
| except (requests.exceptions.RequestException, KeyError) as e: | ||
| message = f"{AUTHENTICATION_FAILED_ACCESS_TOKEN_FROM_REFRESH_TOKEN}{e!s}" |
There was a problem hiding this comment.
Security concern: The exception string may contain sensitive information from the request (potentially including the refresh token).
Consider sanitizing:
error_msg = str(e)
if isinstance(e, requests.exceptions.HTTPError) and e.response is not None:
error_msg = f"HTTP {e.response.status_code}: {e.response.reason}"
message = f"{AUTHENTICATION_FAILED_ACCESS_TOKEN_FROM_REFRESH_TOKEN}{error_msg}"
| """ | ||
| # Create a mock response with 401 Unauthorized (client error) | ||
| mock_response = Mock() | ||
| mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( |
There was a problem hiding this comment.
This test inadvertently masks the bug in the production code by manually injecting "Client Error:" into the exception message.
In real scenarios, requests.exceptions.HTTPError raised by raise_for_status() won't contain this string, so the retry logic won't work as expected.
Suggest updating to test with realistic HTTPError objects:
mock_response.status_code = 401
mock_response.reason = "Unauthorized"
mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(
response=mock_response
)…access token and on verifying said access token fix(platform): Remove unused authorization_backoff_seconds setting refactor(platform): Use proper error messages and logging on failure (of attempts) ro exchange refresh token and verify access token
Code Review: PR #167 - Retries for AuthenticationSummaryThis PR adds configurable retry logic for authentication token operations (refresh token exchange and JWT verification) using the tenacity library. The implementation is solid and follows best practices. Strengths
Suggestions for Consideration
SecurityGood practices maintained: SecretStr for tokens, Sentry monitoring, no sensitive data in errors, 4xx fail fast PerformancePositive: JWK caching reduces requests, retry only on transient failures, reasonable backoff (1s-5s) Recommendations Priority
ApprovalThis PR is ready to merge. Core implementation is sound, well-tested, and follows repository architecture principles. Great work on comprehensive tests, smart retry strategy, performance optimization, and clear error messages! |
refactor(platform): consistently use HTTPStatus refactor(platform): use constraints on platform settings
Pull Request Review: Retries for AuthenticationI've reviewed this PR implementing configurable retry logic for authentication operations. Overall, this is a solid improvement to the SDK's robustness, but there are some important issues to address, particularly with failing tests. Critical Issues
The tests are failing because the cached function uses url as a cache key. The issue is that timeout and lifespan settings are fetched fresh each time from settings(), which means if settings change, the cache won't be invalidated. Recommendation: Include timeout and lifespan in the LRU cache key to ensure cache invalidation when configuration changes.
The new tests are failing because they're mocking jwt.PyJWKClient directly, but the code now uses the cached _get_jwk_client() function. The mocks need to patch _get_jwk_client instead. What's Done Well
RecommendationsBefore merging:
Nice to have: SummaryThis PR significantly improves SDK resilience to transient authentication failures. The retry logic is well-designed and follows best practices. Main blocker is test failures from caching implementation. Estimated effort to fix: 1-2 hours |
There was a problem hiding this comment.
Pull Request Overview
Copilot reviewed 15 out of 16 changed files in this pull request and generated 4 comments.
Comments suppressed due to low confidence (1)
src/aignostics/platform/_settings.py:1
- [nitpick] The conditional logic for handling empty error locations could be clearer. Consider extracting this logic into a helper function or adding a comment explaining when error['loc'] would be empty.
"""Settings of the Python SDK."""
Pull Request Review: Retries for authenticationSummaryThis PR adds configurable retry logic for authentication operations (refresh token exchange and JWT verification) and includes comprehensive test coverage. The implementation is well-structured and follows good practices. ✅ Strengths1. Excellent Retry Strategy
2. Security Improvements
3. Performance Optimization
4. Outstanding Test Coverage
🔍 Areas for Improvement1. Settings Cache Issue (Critical)The Recommendation: Consider whether this is the intended behavior or if the cache should be cleared when settings change. 2. Type Annotation InconsistencyThe return type of Recommendation: Use 3. Potential Race Condition in LRU CacheThe LRU cache is keyed only by URL, but also uses runtime settings values. If settings change between cache hits, the cached client may have stale timeout/lifespan values. Recommendation: Either include timeout and lifespan in the cache key, document that settings should not change during runtime, or clear the cache when settings change. 4. Hardcoded Retry ParametersThe 5. Dependency VersionConsider pinning tenacity to a minor version range (e.g., 🔒 Security Review✅ No security concerns identified
🚀 Performance Considerations✅ Well optimized
📊 Test Coverage✅ Excellent coverage (533 new lines)
🎯 Recommendations Priority
Overall Assessment✅ APPROVE with minor suggestions This is a high-quality PR that significantly improves authentication reliability. The retry logic is well-designed, security considerations are addressed, and test coverage is excellent. The identified issues are minor and can be addressed in follow-up PRs or before merge. Great work on the comprehensive test suite and thoughtful error handling! 🎉 |
refactor(platform): lower defaults for wait times from 1s to 0.1s refactor(platform): allow wait times min/max to be equal refactor(platform): make test fixtures of platform module dry by moving to platform specific conftest
Pull Request Review: Retries and Caching, Step 1This PR introduces configurable retry logic and caching for authentication operations. Overall this is excellent work with comprehensive testing and smart design decisions. Key Strengths1. Excellent Test Coverage (500+ lines of tests)
2. Smart Retry Strategy
3. Performance Optimization
4. Code Quality
Areas for Improvement1. JWK Cache Invalidation (authentication.py:47-72)
2. Retry Configuration Validation (settings.py:400-422)
3. Type Safety (authentication.py:524-556)
4. Settings Cache Thread Safety (settings.py:439-442)
Security AssessmentGood practices:
Consider:
ConclusionRecommendation: APPROVE with minor suggestions This is high-quality, production-ready code. The suggestions above are about hardening edge cases and long-term maintainability. The test coverage is excellent (85%+ requirement likely met) and gives strong confidence in the implementation. Great work on this PR! |
Pull Request Review: Retries and Caching, Step 1OverviewThis PR introduces configurable retries for authentication operations and client request caching. The changes are substantial (2,759 additions, 355 deletions across 25 files) with comprehensive test coverage. ✅ Strengths1. Excellent Test Coverage
2. Robust Retry Implementation
3. Smart Caching Strategy
4. Security Conscious
🐛 Issues & Concerns1. Critical: Type Safety Issue in Cached DecoratorLocation: The @cached_operation(ttl=60) # Returns object
def me(self) -> Me: # Claims to return MeImpact: Type checkers will fail. MyPy strict mode should catch this. Fix: Update decorator to preserve type information: from typing import TypeVar, ParamSpec
P = ParamSpec('P')
R = TypeVar('R')
@staticmethod
def cached_operation(ttl: int) -> Callable[[Callable[P, R]], Callable[P, R]]:
def decorator(func: Callable[P, R]) -> Callable[P, R]:
@wraps(func)
def wrapper(self: "Client", *args: P.args, **kwargs: P.kwargs) -> R:
# ... existing code ...
return result # type: ignore[return-value]
return wrapper # type: ignore[return-value]
return decorator2. Thread Safety: Global Cache DictionaryLocation: _operation_cache: ClassVar[dict[str, tuple[Any, float]]] = {}Issue: Shared mutable state accessed from multiple threads without synchronization. If multiple threads call Risk Level: Medium (data corruption in cache, duplicate API calls) Fix: Use import threading
_operation_cache: ClassVar[dict[str, tuple[Any, float]]] = {}
_operation_cache_lock: ClassVar[threading.RLock] = threading.RLock()
# In wrapper:
with Client._operation_cache_lock:
if cache_key in Client._operation_cache:
# ... existing code ...3. Retry Logic Not Applied to
|
Pull Request Review: Retries and Caching, Step 1SummaryThis PR introduces significant improvements to the platform module with configurable retry logic for authentication operations and caching for the ✅ Strengths1. Excellent Test Coverage
2. Clean Architecture
3. Security Considerations
4. Configuration & Observability
🔍 Areas for Improvement1. Thread Safety Concerns (High Priority)Issue: The class-level _operation_cache: ClassVar[dict[str, tuple[Any, float]]] = {}Problem: Multiple threads could simultaneously:
Recommendation: Use from threading import Lock
_cache_lock = Lock()
# In cached_operation decorator:
with _cache_lock:
if cache_key in Client._operation_cache:
# ... cache logicLocation: 2. Cache Memory Growth (Medium Priority)Issue: No cache size limits or eviction policy beyond TTL. Problem: In long-running applications with many different tokens or operation parameters, the cache could grow unbounded until entries expire. Recommendation: Add a maximum cache size with LRU eviction: from cachetools import TTLCache
_operation_cache: ClassVar[TTLCache] = TTLCache(maxsize=1000, ttl=60)Location: 3. Retry Logic Configuration Mismatch (Low Priority)Issue: JWK_CLIENT_CACHE_SIZE = 4 # HardcodedObservation: The comment states "Multiple entries exist in the rare case of settings changing at runtime only" - but if settings can change at runtime, this creates cache invalidation gaps. Recommendation: Either:
Location: 4. Type Safety Enhancement (Low Priority)Issue: decoded = t.cast("dict[str, str]", jwt.decode(...))Concern: JWT claims can contain non-string values (numbers, bools, arrays). The cast assumes all values are strings but doesn't validate. Recommendation: Add runtime validation or adjust type hints: def _do_verify_and_decode_token(token: str) -> dict[str, Any]: # More accurate
decoded = jwt.decode(...)
# Optionally validate required string fields
return decodedLocation: 5. Code Duplication (Low Priority)Issue: Retry configuration is duplicated between Recommendation: Extract to a shared helper or settings-based factory: def _get_retryer(
retry_condition,
max_attempts_setting: str,
wait_min_setting: str,
wait_max_setting: str
) -> Retrying:
s = settings()
return Retrying(
retry=retry_condition,
stop=stop_after_attempt(getattr(s, max_attempts_setting)),
wait=wait_exponential_jitter(
initial=getattr(s, wait_min_setting),
max=getattr(s, wait_max_setting)
),
before_sleep=before_sleep_log(logger, logging.WARNING),
reraise=True,
)Location: 6. Documentation Clarity (Low Priority)Issue: The infinite polling loop in # Infinite polling for access token with received device code. It's
# a feature and safe to poll infinitely, not a bug.
while True:Recommendation: Explain why it's safe (user-initiated flow with server-side timeout). Location: 🚀 Performance ConsiderationsPositive
Potential Concerns
🔒 Security AssessmentStrengths
Considerations
📝 Code QualityStyle & Standards
Minor Nitpicks
🧪 Testing QualityCoverage
Suggestions
📚 DocumentationStrengths
Suggestions
🎯 Recommendations PriorityMust Fix Before Merge
Should Fix
Nice to Have
✨ ConclusionThis is a high-quality PR that significantly improves the robustness of the platform module. The retry logic is well-implemented with proper backoff strategies, and the caching mechanism is thoughtfully designed. The test coverage is exemplary. The main concern is thread safety of the cache, which should be addressed before merging to production. Otherwise, this is excellent work that follows best practices for resilient API client design. Recommended Action: Approve with minor changes requested (thread safety fix). Review generated by Claude Code following repository standards from |
chore(xdist): have workers steal tests given we have tests with varying duration refactor(platform): use more gracious wait times, and retry more often refactor(linter): cached op micro issue
Pull Request Review: Retries and Caching, Step 1This PR introduces configurable retry mechanisms for authentication operations and caching for the me() API endpoint. Overall, this is a solid implementation with comprehensive test coverage. Strengths
Issues & RecommendationsHIGH PRIORITY: Cache Memory LeakLocation: src/aignostics/platform/_client.py:82 The _operation_cache dict is never cleaned up. Expired entries remain in memory forever, which could cause memory issues in long-running applications with token rotation. Recommendation: Add cleanup on access or use cachetools.TTLCache MEDIUM: Type Safety IssueLocation: src/aignostics/platform/_authentication.py:209 JWT claims are typed as dict[str, str] but actually contain mixed types (exp is int). This could cause runtime errors. Recommendation: Use dict[str, Any] or a Pydantic model MEDIUM: Infinite Polling in Device FlowLocation: src/aignostics/platform/_authentication.py:449 Device flow has infinite polling without timeout, unlike other auth methods with configurable retries. Recommendation: Add timeout or max attempts LOW: Test ParallelismLocation: .github/workflows/_test.yml:20 Running 16 workers on 4 cores may cause test flakiness with timing-sensitive retry tests. Recommendation: Use auto or 8 workers Security & PerformanceGood practices:
Minor concerns:
ApprovalApprove with minor changes. The cache memory leak should be addressed before merge, but other issues are minor enhancements. Great work on this resilience improvement! |
Code Review: Retries and Caching, Step 1This PR introduces configurable retry logic for authentication operations and a caching mechanism for the Client.me() method. Overall, this is a well-structured implementation with comprehensive test coverage. Strengths
Critical Issues (HIGH PRIORITY)1. Thread Safety IssueLocation: src/aignostics/platform/_client.py:82 The class-level _operation_cache dictionary is not thread-safe. Concurrent access could cause race conditions. Recommendation: Add threading.RLock for cache operations 2. Memory Leak RiskLocation: src/aignostics/platform/_client.py:82 The cache dictionary grows indefinitely. Expired entries are only removed when accessed. Recommendation: Use bounded cache like cachetools.TTLCache or implement periodic cleanup Important Issues (MEDIUM PRIORITY)3. Infinite Polling in Device FlowLocation: src/aignostics/platform/_authentication.py:447-471 No timeout on device flow polling. Could block indefinitely if auth server has issues. Recommendation: Add configurable maximum wait time 4. Type Safety ConcernLocation: src/aignostics/platform/_authentication.py:265-270 Using cast to force JWT claims to dict[str, str] without actual conversion. Claims can be various types. Recommendation: Either validate/convert claim types or change return type to dict[str, Any] Security AssessmentNo major security concerns. Secrets properly handled, error messages sanitized, JWT verification correct. Performance Notes
TestingExcellent coverage but missing:
Final AssessmentOverall: Approve with changes This PR implements important resilience features with good test coverage. However, thread safety and memory leak issues should be addressed before production. Scores:
|
| - Caches operation results for specific operations. | ||
| """ | ||
|
|
||
| _operation_cache: ClassVar[dict[str, tuple[Any, float]]] = {} |
There was a problem hiding this comment.
Thread Safety Issue: This class-level cache dictionary is not thread-safe. Concurrent access from multiple threads could lead to race conditions when reading/writing cache entries.
Recommendation: Add a threading.RLock to protect cache operations:
from threading import RLock
class Client:
_operation_cache: ClassVar[dict[str, tuple[Any, float]]] = {}
_cache_lock: ClassVar[RLock] = RLock()Then wrap all cache access in cached_operation decorator with with Client._cache_lock:.
Pull Request Review: Retries and Caching, Step 1SummaryThis PR introduces configurable retry logic for authentication operations and adds caching for the "me" operation. The changes improve resilience against transient network failures while avoiding unnecessary retries on client errors (4xx). Positive Aspects ✅
Issues & Concerns 🔴1. Tenacity Invocation Pattern (
|
chore(bucket): more grace in test
chore(bucket): more grace in test
Pull Request Review: Retries and Caching, Step 1This PR introduces comprehensive retry handling and caching mechanisms for authentication and API operations, significantly improving reliability in the face of transient errors. Strengths1. Excellent Retry Strategy
2. Authentication-Aware Caching
3. Connection Pooling
4. Comprehensive Test Coverage
Areas for Improvement1. Type Annotation Issue (Minor) 2. Cache Invalidation Strategy 3. Error Message Sanitization Security ReviewGood Practices:
Minor Concerns:
Recommendations SummaryMust Fix:
Should Consider: Nice to Have: Final VerdictApprove with minor suggestions. This is a well-engineered PR that significantly improves reliability. The retry logic is robust, the caching is clever, and the test coverage is excellent. The identified issues are minor and do not block merging. Risk Level: Low | Breaking Changes: None | Readiness: Production-ready Great work on comprehensive error handling! |
Pull Request Review: Retries and Caching, Step 1SummaryThis PR introduces configurable retry logic and caching for authentication and API operations, significantly improving resilience against transient network and server failures. Strengths
Critical Issues1. Thread Safety - Client._operation_cache (HIGH PRIORITY)Location: src/aignostics/platform/_client.py:82-84 Class-level dictionary accessed without synchronization. Race conditions possible during concurrent reads/writes/deletes. Fix: Add threading.RLock() synchronization or use cachetools TTLCache. 2. API Client Pooling Thread SafetyLocation: src/aignostics/platform/_client.py:234-260 Class-level API client instances not thread-safe. Concurrent threads may use stale clients if settings change. Fix: Use thread-local storage or per-instance clients. High Priority3. Missing Retry Logic in Device FlowLocation: src/aignostics/platform/_authentication.py:449-471 Device flow polling has no retry logic. Network errors terminate entire auth flow. Fix: Wrap request in retry logic similar to _access_token_from_refresh_token. Medium Priority4. Unbounded Cache GrowthLocation: src/aignostics/platform/_client.py:82-84 _operation_cache grows unbounded, potential memory leak in long-running processes. Fix: Implement cache size limits or use cachetools with maxsize parameter. 5. JWT Type Casting SafetyLocation: src/aignostics/platform/_authentication.py:265-270 t.cast assumes all JWT claims are strings, but exp is typically int. Fix: Use dict[str, Any] or document assumption clearly. 6. Validation LogicLocation: src/aignostics/platform/_settings.py:409 Validation disallows auth_retry_wait_min == auth_retry_wait_max, but this is valid (fixed wait time). Testing RecommendationsConsider adding:
SecurityGood practices observed: sanitized errors, SecretStr usage, masked logging. Minor concern: Error messages expose token URL - verify this is acceptable. PerformanceImprovements: connection reuse, cached JWK fetching, operation caching. Concern: Unbounded cache in long-running processes. ConclusionOverall Assessment: High-quality PR with excellent retry implementation and test coverage. Recommendation: Approve with changes Must Fix Before Merge:
Nice to Have:
Code Quality: 4/5 stars Great work! The retry and caching mechanisms significantly improve SDK robustness. Please address the thread-safety concerns before merging. |
|
Pull Request Review: Retries and Caching, Step 1 Overall Assessment: This is a well-implemented enhancement with excellent test coverage. The retry and caching mechanisms are thoughtfully designed and follow best practices. STRENGTHS:
ISSUES & CONCERNS: CRITICAL: Type Casting Safety Issue HIGH: Dependency Pinning Concerns MEDIUM: Infinite Retry Loop MEDIUM: Cache Invalidation Strategy MEDIUM: Settings Validation Gap QUESTIONS:
MINOR ISSUES:
PERFORMANCE CONSIDERATIONS:
SUMMARY: This is a high-quality PR with thoughtful design and implementation. The retry and caching mechanisms are well-architected and tested. Recommendation: APPROVE WITH MINOR CHANGES Must Fix:
Should Fix: Nice to Have: Great work overall! The codebase follows the repository architecture principles and coding standards. The addition of retry and caching will significantly improve resilience and performance. Review conducted following repository conventions from CLAUDE.md and CODE_STYLE.md |
|
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
* fix(platform): Remove unused setting authorization_backoff_seconds * feat(platform): Auto-retry when retrieving JWKS set from auth0 * feat(platform): Cache JWKS set, TTL 24h, minimizing calls to auth0 on validating access tokens * feat(platform): Auto-retry when calling auth0 to exchange refresh token for access token * refactor(platform): Use proper error messages and logging on failure (of attempts) to exchange refresh token and validate access token * fix(utils): surface setting validation error on misconfigured api root * refactor(platform): consistently use HTTPStatus consts instead of 200, 500 etc. * refactor(platform): use proper constraints on settings * fix(platform): fix wrong exception handler in _perform_device_flow - was catching exception from urllib, not requests lib * feat(platform): configurable timeout for requesting platform health * feat(platform): introduce authentication aware operation cache * feat(platform): use authentication aware operation cache to cache /me result * chore(pytst): Add pytest-durations plugin to show durations of fixtures and tests * refactor(platform,system): optimize connection pooling * fix(platform): use dynamic user agent for requesting /me * style(utils): consistent log formatting for file and console, both including process id
feat(platform): Configurable retries on exchanging refresh token for access token and on verifying said access token
fix(platform): Remove unused authorization_backoff_seconds setting
refactor(platform): Use proper error messages and logging on failure (of attempts) ro exchange refresh token and verify access token