port-ocean 0.4.2rc2__tar.gz → 0.4.4__tar.gz

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.4.2rc2
+Version: 0.4.4
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/clients/port/authentication.py

@@ -42,7 +42,7 @@ class PortAuthentication:
         self.integration_identifier = integration_identifier
         self.integration_type = integration_type
         self.integration_version = integration_version
-        self._last_token_object: TokenResponse | None = None
+        self.last_token_object: TokenResponse | None = None
 
     async def _get_token(self, client_id: str, client_secret: str) -> TokenResponse:
         logger.info(f"Fetching access token for clientId: {client_id}")
@@ -71,9 +71,13 @@ class PortAuthentication:
 
     @property
     async def token(self) -> str:
-        if not self._last_token_object or self._last_token_object.expired:
-            self._last_token_object = await self._get_token(
+        if not self.last_token_object or self.last_token_object.expired:
+            msg = "Token expired, fetching new token"
+            if not self.last_token_object:
+                msg = "No token found, fetching new token"
+            logger.info(msg)
+            self.last_token_object = await self._get_token(
                 self.client_id, self.client_secret
             )
 
-        return self._last_token_object.full_token
+        return self.last_token_object.full_token

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/clients/port/client.py

@@ -8,7 +8,10 @@ from port_ocean.clients.port.mixins.migrations import MigrationClientMixin
 from port_ocean.clients.port.types import (
     KafkaCreds,
 )
-from port_ocean.clients.port.utils import handle_status_code, async_client
+from port_ocean.clients.port.utils import (
+    handle_status_code,
+    get_internal_http_client,
+)
 from port_ocean.exceptions.clients import KafkaCredentialsNotFound
 
 
@@ -28,7 +31,7 @@ class PortClient(
         integration_version: str,
     ):
         self.api_url = f"{base_url}/v1"
-        self.client = async_client
+        self.client = get_internal_http_client(self)
         self.auth = PortAuthentication(
             self.client,
             client_id,

port_ocean-0.4.4/port_ocean/clients/port/retry_transport.py

@@ -0,0 +1,51 @@
+import asyncio
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from port_ocean.helpers.retry import RetryTransport
+
+if TYPE_CHECKING:
+    from port_ocean.clients.port.client import PortClient
+
+
+class TokenRetryTransport(RetryTransport):
+    def __init__(self, port_client: "PortClient", *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.port_client = port_client
+
+    async def _handle_unauthorized(self, response: httpx.Response) -> None:
+        token = await self.port_client.auth.token
+        response.headers["Authorization"] = f"Bearer {token}"
+
+    def is_token_error(self, response: httpx.Response) -> bool:
+        return (
+            response.status_code == HTTPStatus.UNAUTHORIZED
+            and "/auth/access_token" not in str(response.request.url)
+            and self.port_client.auth.last_token_object is not None
+            and self.port_client.auth.last_token_object.expired
+        )
+
+    async def _should_retry_async(self, response: httpx.Response) -> bool:
+        if self.is_token_error(response):
+            if self._logger:
+                self._logger.info(
+                    "Got unauthorized response, trying to refresh token before retrying"
+                )
+            await self._handle_unauthorized(response)
+            return True
+        return await super()._should_retry_async(response)
+
+    def _should_retry(self, response: httpx.Response) -> bool:
+        if self.is_token_error(response):
+            if self._logger:
+                self._logger.info(
+                    "Got unauthorized response, trying to refresh token before retrying"
+                )
+            asyncio.get_running_loop().run_until_complete(
+                self._handle_unauthorized(response)
+            )
+
+            return True
+        return super()._should_retry(response)

port_ocean-0.4.4/port_ocean/clients/port/utils.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+
+import httpx
+from loguru import logger
+from werkzeug.local import LocalStack, LocalProxy
+
+from port_ocean.clients.port.retry_transport import TokenRetryTransport
+
+if TYPE_CHECKING:
+    from port_ocean.clients.port.client import PortClient
+
+_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
+
+
+def _get_http_client_context(port_client: "PortClient") -> httpx.AsyncClient:
+    client = _http_client.top
+    if client is None:
+        client = httpx.AsyncClient(
+            transport=TokenRetryTransport(
+                port_client,
+                httpx.AsyncHTTPTransport(),
+                logger=logger,
+            )
+        )
+        _http_client.push(client)
+
+    return client
+
+
+_port_internal_async_client: httpx.AsyncClient = None  # type: ignore
+
+
+def get_internal_http_client(port_client: "PortClient") -> httpx.AsyncClient:
+    global _port_internal_async_client
+    if _port_internal_async_client is None:
+        _port_internal_async_client = LocalProxy(
+            lambda: _get_http_client_context(port_client)
+        )
+
+    return _port_internal_async_client
+
+
+def handle_status_code(
+    response: httpx.Response, should_raise: bool = True, should_log: bool = True
+) -> None:
+    if should_log and response.is_error:
+        logger.error(
+            f"Request failed with status code: {response.status_code}, Error: {response.text}"
+        )
+    if should_raise:
+        response.raise_for_status()

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/consumers/kafka_consumer.py

@@ -1,8 +1,5 @@
-import asyncio
-import json
 import signal
-import sys
-from typing import Any, Callable, Awaitable
+from typing import Any, Callable
 
 from confluent_kafka import Consumer, KafkaException, Message  # type: ignore
 from loguru import logger
@@ -25,7 +22,7 @@ class KafkaConsumerConfig(BaseModel):
 class KafkaConsumer(BaseConsumer):
     def __init__(
         self,
-        msg_process: Callable[[dict[Any, Any], str], Awaitable[None]],
+        msg_process: Callable[[Message], None],
         config: KafkaConsumerConfig,
         org_id: str,
     ) -> None:
@@ -56,23 +53,6 @@ class KafkaConsumer(BaseConsumer):
 
         self.consumer = Consumer(kafka_config)
 
-    def _handle_message(self, raw_msg: Message) -> None:
-        message = json.loads(raw_msg.value().decode())
-        topic = raw_msg.topic()
-
-        async def try_wrapper() -> None:
-            try:
-                await self.msg_process(message, topic)
-            except Exception as e:
-                _type, _, tb = sys.exc_info()
-                logger.opt(exception=(_type, None, tb)).error(
-                    f"Failed to process message: {str(e)}"
-                )
-
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        loop.run_until_complete(try_wrapper())
-
     def start(self) -> None:
         try:
             logger.info("Start consumer...")
@@ -98,7 +78,8 @@ class KafkaConsumer(BaseConsumer):
                                 "Process message "
                                 f"from topic {msg.topic()}, partition {msg.partition()}, offset {msg.offset()}"
                             )
-                            self._handle_message(msg)
+                            self.msg_process(msg)
+
                         except Exception as process_error:
                             logger.exception(
                                 "Failed process message"

port_ocean-0.4.4/port_ocean/context/utils.py

@@ -0,0 +1,24 @@
+from typing import Callable
+
+from port_ocean.context.ocean import (
+    initialize_port_ocean_context,
+    ocean,
+)
+
+
+def wrap_method_with_context(
+    func: Callable[..., None],
+) -> Callable[..., None]:
+    """
+    A method that wraps a method and initializing the PortOceanContext and invoking the given function.
+
+    :param func: The function to be wrapped.
+    """
+    # assign the current ocean app to a variable
+    ocean_app = ocean.app
+
+    def wrapper(*args, **kwargs) -> None:  # type: ignore
+        initialize_port_ocean_context(ocean_app=ocean_app)
+        func(*args, **kwargs)
+
+    return wrapper

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/core/event_listener/kafka.py

@@ -1,14 +1,17 @@
+import asyncio
+import json
+import sys
 import threading
-from typing import Any, Callable, Literal
+from typing import Any, Literal
 
+from confluent_kafka import Message  # type: ignore
 from loguru import logger
 
 from port_ocean.consumers.kafka_consumer import KafkaConsumer, KafkaConsumerConfig
 from port_ocean.context.ocean import (
-    PortOceanContext,
-    initialize_port_ocean_context,
     ocean,
 )
+from port_ocean.context.utils import wrap_method_with_context
 from port_ocean.core.event_listener.base import (
     BaseEventListener,
     EventListenerEvents,
@@ -100,30 +103,48 @@ class KafkaEventListener(BaseEventListener):
 
         return False
 
-    async def _handle_message(self, message: dict[Any, Any], topic: str) -> None:
+    def _resync_in_new_event_loop(self, message: dict[Any, Any]) -> None:
         """
-        A private method that handles incoming Kafka messages.
-        If the message should be processed (determined by `_should_be_processed`), it triggers the corresponding event handler.
+        A private method that handles incoming Kafka messages in a separate thread.
+        It triggers the `on_resync` event handler.
         """
-        if not self._should_be_processed(message, topic):
-            return
 
-        if "change.log" in topic and message is not None:
-            await self.events["on_resync"](message)
+        async def try_wrapper() -> None:
+            try:
+                await self.events["on_resync"](message)
+            except Exception as e:
+                _type, _, tb = sys.exc_info()
+                logger.opt(exception=(_type, None, tb)).error(
+                    f"Failed to process message: {str(e)}"
+                )
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(try_wrapper())
 
-    def _wrapped_start(
-        self, context: PortOceanContext, func: Callable[[], None]
-    ) -> Callable[[], None]:
+    def _handle_message(self, raw_msg: Message) -> None:
         """
-        A method that wraps the `start` method, initializing the PortOceanContext and invoking the given function.
+        A private method that handles incoming Kafka messages.
+        If the message should be processed (determined by `_should_be_processed`), it triggers the corresponding event handler.
+
+        Spawning a thread to handle the message allows the Kafka consumer to continue polling for new messages.
+        Using wrap_method_with_context ensures that the thread has access to the current context.
         """
-        ocean_app = context.app
+        message = json.loads(raw_msg.value().decode())
+        topic = raw_msg.topic()
 
-        def wrapper() -> None:
-            initialize_port_ocean_context(ocean_app=ocean_app)
-            func()
+        if not self._should_be_processed(message, topic):
+            return
 
-        return wrapper
+        if "change.log" in topic and message is not None:
+            thread_name = f"ocean_event_handler_{raw_msg.offset()}"
+            logger.info(f"spawning thread {thread_name} to start resync")
+            threading.Thread(
+                name=thread_name,
+                target=wrap_method_with_context(self._resync_in_new_event_loop),
+                args=(message,),
+            ).start()
+            logger.info(f"thread {thread_name} started")
 
     async def start(self) -> None:
         """
@@ -138,5 +159,5 @@ class KafkaEventListener(BaseEventListener):
         logger.info("Starting Kafka consumer")
         threading.Thread(
             name="ocean_kafka_consumer",
-            target=self._wrapped_start(ocean, consumer.start),
+            target=wrap_method_with_context(func=consumer.start),
         ).start()

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py

@@ -1,7 +1,8 @@
-from graphlib import TopologicalSorter
+from graphlib import TopologicalSorter, CycleError
 from typing import Set
 
 from port_ocean.core.models import Entity
+from port_ocean.exceptions.core import OceanAbortException
 
 Node = tuple[str, str]
 
@@ -35,4 +36,11 @@ def order_by_entities_dependencies(entities: list[Entity]) -> list[Entity]:
             nodes[node(entity)].add(node(related_entity))
 
     sort_op = TopologicalSorter(nodes)
-    return [entities_map[item] for item in sort_op.static_order()]
+    try:
+        return [entities_map[item] for item in sort_op.static_order()]
+    except CycleError as ex:
+        raise OceanAbortException(
+            "Cannot order entities due to cyclic dependencies. \n"
+            "If you do want to have cyclic dependencies, please make sure to set the keys"
+            " 'createMissingRelatedEntities' and 'deleteDependentEntities' in the integration config in Port."
+        ) from ex

port_ocean-0.4.4/port_ocean/helpers/retry.py

@@ -0,0 +1,267 @@
+import asyncio
+import random
+import time
+from datetime import datetime
+from functools import partial
+from http import HTTPStatus
+from typing import Any, Callable, Coroutine, Iterable, Mapping, Union
+
+import httpx
+from dateutil.parser import isoparse  # type: ignore
+
+
+# Adapted from https://github.com/encode/httpx/issues/108#issuecomment-1434439481
+class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
+    """
+    A custom HTTP transport that automatically retries requests using an exponential backoff strategy
+    for specific HTTP status codes and request methods.
+
+    Args:
+        wrapped_transport (Union[httpx.BaseTransport, httpx.AsyncBaseTransport]): The underlying HTTP transport
+            to wrap and use for making requests.
+        max_attempts (int, optional): The maximum number of times to retry a request before giving up. Defaults to 10.
+        max_backoff_wait (float, optional): The maximum time to wait between retries in seconds. Defaults to 60.
+        backoff_factor (float, optional): The factor by which the wait time increases with each retry attempt.
+            Defaults to 0.1.
+        jitter_ratio (float, optional): The amount of jitter to add to the backoff time. Jitter is a random
+            value added to the backoff time to avoid a "thundering herd" effect. The value should be between 0 and 0.5.
+            Defaults to 0.1.
+        respect_retry_after_header (bool, optional): Whether to respect the Retry-After header in HTTP responses
+            when deciding how long to wait before retrying. Defaults to True.
+        retryable_methods (Iterable[str], optional): The HTTP methods that can be retried. Defaults to
+            ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"].
+        retry_status_codes (Iterable[int], optional): The HTTP status codes that can be retried. Defaults to
+            [429, 502, 503, 504].
+
+    Attributes:
+        _wrapped_transport (Union[httpx.BaseTransport, httpx.AsyncBaseTransport]): The underlying HTTP transport
+            being wrapped.
+        _max_attempts (int): The maximum number of times to retry a request.
+        _backoff_factor (float): The factor by which the wait time increases with each retry attempt.
+        _respect_retry_after_header (bool): Whether to respect the Retry-After header in HTTP responses.
+        _retryable_methods (frozenset): The HTTP methods that can be retried.
+        _retry_status_codes (frozenset): The HTTP status codes that can be retried.
+        _jitter_ratio (float): The amount of jitter to add to the backoff time.
+        _max_backoff_wait (float): The maximum time to wait between retries in seconds.
+
+    """
+
+    RETRYABLE_METHODS = frozenset(["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"])
+    RETRYABLE_STATUS_CODES = frozenset(
+        [
+            HTTPStatus.TOO_MANY_REQUESTS,
+            HTTPStatus.BAD_GATEWAY,
+            HTTPStatus.SERVICE_UNAVAILABLE,
+            HTTPStatus.GATEWAY_TIMEOUT,
+        ]
+    )
+    MAX_BACKOFF_WAIT = 60
+
+    def __init__(
+        self,
+        wrapped_transport: Union[httpx.BaseTransport, httpx.AsyncBaseTransport],
+        max_attempts: int = 10,
+        max_backoff_wait: float = MAX_BACKOFF_WAIT,
+        backoff_factor: float = 0.1,
+        jitter_ratio: float = 0.1,
+        respect_retry_after_header: bool = True,
+        retryable_methods: Iterable[str] | None = None,
+        retry_status_codes: Iterable[int] | None = None,
+        logger: Any | None = None,
+    ) -> None:
+        """
+        Initializes the instance of RetryTransport class with the given parameters.
+
+        Args:
+            wrapped_transport (Union[httpx.BaseTransport, httpx.AsyncBaseTransport]):
+                The transport layer that will be wrapped and retried upon failure.
+            max_attempts (int, optional):
+                The maximum number of times the request can be retried in case of failure.
+                Defaults to 10.
+            max_backoff_wait (float, optional):
+                The maximum amount of time (in seconds) to wait before retrying a request.
+                Defaults to 60.
+            backoff_factor (float, optional):
+                The factor by which the waiting time will be multiplied in each retry attempt.
+                Defaults to 0.1.
+            jitter_ratio (float, optional):
+                The ratio of randomness added to the waiting time to prevent simultaneous retries.
+                Should be between 0 and 0.5. Defaults to 0.1.
+            respect_retry_after_header (bool, optional):
+                A flag to indicate if the Retry-After header should be respected.
+                If True, the waiting time specified in Retry-After header is used for the waiting time.
+                Defaults to True.
+            retryable_methods (Iterable[str], optional):
+                The HTTP methods that can be retried. Defaults to ['HEAD', 'GET', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'].
+            retry_status_codes (Iterable[int], optional):
+                The HTTP status codes that can be retried.
+                Defaults to [429, 502, 503, 504].
+            logger (Any): The logger to use for logging retries.
+        """
+        self._wrapped_transport = wrapped_transport
+        if jitter_ratio < 0 or jitter_ratio > 0.5:
+            raise ValueError(
+                f"Jitter ratio should be between 0 and 0.5, actual {jitter_ratio}"
+            )
+
+        self._max_attempts = max_attempts
+        self._backoff_factor = backoff_factor
+        self._respect_retry_after_header = respect_retry_after_header
+        self._retryable_methods = (
+            frozenset(retryable_methods)
+            if retryable_methods
+            else self.RETRYABLE_METHODS
+        )
+        self._retry_status_codes = (
+            frozenset(retry_status_codes)
+            if retry_status_codes
+            else self.RETRYABLE_STATUS_CODES
+        )
+        self._jitter_ratio = jitter_ratio
+        self._max_backoff_wait = max_backoff_wait
+        self._logger = logger
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        """
+        Sends an HTTP request, possibly with retries.
+
+        Args:
+            request (httpx.Request): The request to send.
+
+        Returns:
+            httpx.Response: The response received.
+
+        """
+        transport: httpx.BaseTransport = self._wrapped_transport  # type: ignore
+        if request.method in self._retryable_methods:
+            send_method = partial(transport.handle_request)
+            response = self._retry_operation(request, send_method)
+        else:
+            response = transport.handle_request(request)
+        return response
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        """Sends an HTTP request, possibly with retries.
+
+        Args:
+            request: The request to perform.
+
+        Returns:
+            The response.
+
+        """
+        transport: httpx.AsyncBaseTransport = self._wrapped_transport  # type: ignore
+        if request.method in self._retryable_methods:
+            send_method = partial(transport.handle_async_request)
+            response = await self._retry_operation_async(request, send_method)
+        else:
+            response = await transport.handle_async_request(request)
+        return response
+
+    async def aclose(self) -> None:
+        """
+        Closes the underlying HTTP transport, terminating all outstanding connections and rejecting any further
+        requests.
+
+        This should be called before the object is dereferenced, to ensure that connections are properly cleaned up.
+        """
+        transport: httpx.AsyncBaseTransport = self._wrapped_transport  # type: ignore
+        await transport.aclose()
+
+    def close(self) -> None:
+        """
+        Closes the underlying HTTP transport, terminating all outstanding connections and rejecting any further
+        requests.
+
+        This should be called before the object is dereferenced, to ensure that connections are properly cleaned up.
+        """
+        transport: httpx.BaseTransport = self._wrapped_transport  # type: ignore
+        transport.close()
+
+    def _should_retry(self, response: httpx.Response) -> bool:
+        return response.status_code in self._retry_status_codes
+
+    async def _should_retry_async(self, response: httpx.Response) -> bool:
+        return response.status_code in self._retry_status_codes
+
+    def _calculate_sleep(
+        self, attempts_made: int, headers: Union[httpx.Headers, Mapping[str, str]]
+    ) -> float:
+        # Retry-After
+        # The Retry-After response HTTP header indicates how long the user agent should wait before
+        # making a follow-up request. There are three main cases this header is used:
+        # - When sent with a 503 (Service Unavailable) response, this indicates how long the service
+        #   is expected to be unavailable.
+        # - When sent with a 429 (Too Many Requests) response, this indicates how long to wait before
+        #   making a new request.
+        # - When sent with a redirect response, such as 301 (Moved Permanently), this indicates the
+        #   minimum time that the user agent is asked to wait before issuing the redirected request.
+        retry_after_header = (headers.get("Retry-After") or "").strip()
+        if self._respect_retry_after_header and retry_after_header:
+            if retry_after_header.isdigit():
+                return float(retry_after_header)
+
+            try:
+                parsed_date = isoparse(
+                    retry_after_header
+                ).astimezone()  # converts to local time
+                diff = (parsed_date - datetime.now().astimezone()).total_seconds()
+                if diff > 0:
+                    return min(diff, self._max_backoff_wait)
+            except ValueError:
+                pass
+
+        backoff = self._backoff_factor * (2 ** (attempts_made - 1))
+        jitter = (backoff * self._jitter_ratio) * random.choice([1, -1])
+        total_backoff = backoff + jitter
+        return min(total_backoff, self._max_backoff_wait)
+
+    async def _retry_operation_async(
+        self,
+        request: httpx.Request,
+        send_method: Callable[..., Coroutine[Any, Any, httpx.Response]],
+    ) -> httpx.Response:
+        remaining_attempts = self._max_attempts
+        attempts_made = 0
+        while True:
+            response: httpx.Response
+            if attempts_made > 0:
+                sleep_time = self._calculate_sleep(attempts_made, {})
+                if self._logger:
+                    self._logger.warning(
+                        f"Request {request.method} {request.url} failed with status code:"
+                        f" {response.status_code}, retrying in {sleep_time} seconds."  # noqa: F821
+                    )
+                await asyncio.sleep(sleep_time)
+            response = await send_method(request)
+            response.request = request
+            if remaining_attempts < 1 or not (await self._should_retry_async(response)):
+                return response
+            await response.aclose()
+            attempts_made += 1
+            remaining_attempts -= 1
+
+    def _retry_operation(
+        self,
+        request: httpx.Request,
+        send_method: Callable[..., httpx.Response],
+    ) -> httpx.Response:
+        remaining_attempts = self._max_attempts
+        attempts_made = 0
+        while True:
+            response: httpx.Response
+            if attempts_made > 0:
+                sleep_time = self._calculate_sleep(attempts_made, {})
+                if self._logger:
+                    self._logger.warning(
+                        f"Request {request.method} {request.url} failed with status code:"
+                        f" {response.status_code}, retrying in {sleep_time} seconds."  # noqa: F821
+                    )
+                time.sleep(sleep_time)
+            response = send_method(request)
+            response.request = request
+            if remaining_attempts < 1 or not self._should_retry(response):
+                return response
+            response.close()
+            attempts_made += 1
+            remaining_attempts -= 1

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/port_ocean/utils.py

@@ -3,17 +3,49 @@ import inspect
 from asyncio import ensure_future
 from functools import wraps
 from importlib.util import module_from_spec, spec_from_file_location
-from pathlib import Path
 from time import time
 from traceback import format_exception
 from types import ModuleType
 from typing import Callable, Any, Coroutine
 from uuid import uuid4
 
+import httpx
 import tomli
 import yaml
 from loguru import logger
+from pathlib import Path
 from starlette.concurrency import run_in_threadpool
+from werkzeug.local import LocalStack, LocalProxy
+
+from port_ocean.helpers.retry import RetryTransport
+
+_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
+
+
+def _get_http_client_context() -> httpx.AsyncClient:
+    client = _http_client.top
+    if client is None:
+        client = httpx.AsyncClient(
+            transport=RetryTransport(
+                httpx.AsyncHTTPTransport(),
+                logger=logger,
+            )
+        )
+        _http_client.push(client)
+
+    return client
+
+
+"""
+Utilize this client for all outbound integration requests to the third-party application. It functions as a wrapper 
+around the httpx.AsyncClient, incorporating retry logic at the transport layer for handling retries on 5xx errors and
+connection errors.
+
+The client is instantiated lazily, only coming into existence upon its initial access. It should not be closed when in
+use, as it operates as a singleton shared across all events in the thread. It also takes care of recreating the client
+in scenarios such as the creation of a new event loop, such as when initiating a new thread.
+"""
+http_async_client: httpx.AsyncClient = LocalProxy(lambda: _get_http_client_context())  # type: ignore
 
 
 def get_time(seconds_precision: bool = True) -> float:
@@ -114,12 +146,13 @@ def repeat_every(
                 if wait_first:
                     await asyncio.sleep(seconds)
                 while max_repetitions is None or repetitions < max_repetitions:
+                    # count the repetition even if an exception is raised
+                    repetitions += 1
                     try:
                         if is_coroutine:
                             await func()  # type: ignore
                         else:
                             await run_in_threadpool(func)
-                        repetitions += 1
                     except Exception as exc:
                         formatted_exception = "".join(
                             format_exception(type(exc), exc, exc.__traceback__)

{port_ocean-0.4.2rc2 → port_ocean-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.4.2.rc02"
+version = "0.4.4"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"

port_ocean-0.4.2rc2/port_ocean/clients/port/utils.py

@@ -1,28 +0,0 @@
-import httpx
-from loguru import logger
-from werkzeug.local import LocalStack, LocalProxy
-
-_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
-
-
-def _get_http_client_context() -> httpx.AsyncClient:
-    client = _http_client.top
-    if client is None:
-        client = httpx.AsyncClient()
-        _http_client.push(client)
-
-    return client
-
-
-async_client: httpx.AsyncClient = LocalProxy(lambda: _get_http_client_context())  # type: ignore
-
-
-def handle_status_code(
-    response: httpx.Response, should_raise: bool = True, should_log: bool = True
-) -> None:
-    if should_log and response.is_error:
-        logger.error(
-            f"Request failed with status code: {response.status_code}, Error: {response.text}"
-        )
-    if should_raise:
-        response.raise_for_status()