port-ocean 0.23.4__py3-none-any.whl → 0.24.0__py3-none-any.whl

integrations/_infra/Dockerfile.Deb

@@ -5,15 +5,11 @@ FROM ${BASE_BUILDER_PYTHON_IMAGE} AS base
 
 ARG BUILD_CONTEXT
 ARG BUILDPLATFORM
-ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
 
 ENV LIBRDKAFKA_VERSION=2.8.2 \
     PYTHONUNBUFFERED=1 \
     POETRY_VIRTUALENVS_IN_PROJECT=1 \
-    PIP_ROOT_USER_ACTION=ignore \
-    PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
-
-RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
+    PIP_ROOT_USER_ACTION=ignore
 
 WORKDIR /app
 
@@ -25,8 +21,12 @@ FROM ${BASE_RUNNER_PYTHON_IMAGE} AS prod
 
 ARG INTEGRATION_VERSION
 ARG BUILD_CONTEXT
+ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
 
-ENV LIBRDKAFKA_VERSION=2.8.2
+ENV LIBRDKAFKA_VERSION=2.8.2 \
+    PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
+
+RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 
 RUN apt-get update \
     && apt-get install -y \

port_ocean/clients/port/mixins/entities.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import Any, Literal
 from urllib.parse import quote_plus
-
+import json
 
 import httpx
 from loguru import logger
@@ -12,11 +12,19 @@ from port_ocean.clients.port.utils import (
     handle_port_status_code,
     PORT_HTTP_MAX_CONNECTIONS_LIMIT,
 )
-from port_ocean.core.models import Entity, PortAPIErrorMessage
+from port_ocean.core.models import (
+    BulkUpsertResponse,
+    Entity,
+    PortAPIErrorMessage,
+)
 from starlette import status
 
 from port_ocean.helpers.metric.metric import MetricPhase, MetricType
 
+ENTITIES_BULK_SAMPLES_SIZE = 10
+ENTITIES_BULK_ESTIMATED_SIZE_MULTIPLIER = 1.5
+ENTITIES_BULK_MINIMUM_BATCH_SIZE = 1
+
 
 class EntityClientMixin:
     def __init__(self, auth: PortAuthentication, client: httpx.AsyncClient):
@@ -29,6 +37,42 @@ class EntityClientMixin:
             round(0.5 * PORT_HTTP_MAX_CONNECTIONS_LIMIT)
         )  # 50% of the max connections limit in order to avoid overloading port
 
+    def calculate_entities_batch_size(self, entities: list[Entity]) -> int:
+        """
+        Calculate the optimal batch size based on entity size and configured limits.
+
+        Args:
+            entities: List of entities to calculate batch size for
+
+        Returns:
+            int: The optimal batch size to use
+        """
+        if not entities:
+            return ENTITIES_BULK_MINIMUM_BATCH_SIZE
+
+        # Calculate average entity size from a sample
+        SAMPLE_SIZE = min(ENTITIES_BULK_SAMPLES_SIZE, len(entities))
+        sample_entities = entities[:SAMPLE_SIZE]
+        average_entity_size = (
+            sum(
+                len(json.dumps(entity.dict(exclude_unset=True, by_alias=True)).encode())
+                for entity in sample_entities
+            )
+            / SAMPLE_SIZE
+        )
+
+        # Use a conservative estimate to ensure we stay under the limit
+        estimated_entity_size = int(
+            average_entity_size * ENTITIES_BULK_ESTIMATED_SIZE_MULTIPLIER
+        )
+        max_entities_per_batch = min(
+            ocean.config.upsert_entities_batch_max_length,
+            ocean.config.upsert_entities_batch_max_size_in_bytes
+            // estimated_entity_size,
+        )
+
+        return max(ENTITIES_BULK_MINIMUM_BATCH_SIZE, max_entities_per_batch)
+
     async def upsert_entity(
         self,
         entity: Entity,
@@ -124,38 +168,145 @@ class EntityClientMixin:
             return None
         return self._reduce_entity(result_entity)
 
-    @staticmethod
-    def _reduce_entity(entity: Entity) -> Entity:
+    async def upsert_entities_bulk(
+        self,
+        blueprint: str,
+        entities: list[Entity],
+        request_options: RequestOptions,
+        user_agent_type: UserAgentType | None = None,
+        should_raise: bool = True,
+    ) -> list[tuple[bool | None, Entity]] | httpx.HTTPStatusError:
         """
-        Reduces an entity to only keep identifier, blueprint and processed relations.
-        This helps save memory by removing unnecessary data.
+        This function upserts a list of entities into Port.
 
-        Args:
-            entity: The entity to reduce
+        Usage:
+        ```python
+            upsertedEntities = await self.context.port_client.upsert_entities_batch(
+                            entities,
+                            event.port_app_config.get_port_request_options(),
+                            user_agent_type,
+                            should_raise=False,
+                        )
+        ```
+        :param blueprint: The blueprint of the entities to be upserted
+        :param entities: A list of Entities to be upserted
+        :param request_options: A dictionary specifying how to upsert the entity
+        :param user_agent_type: a UserAgentType specifying who is preforming the action
+        :param should_raise: A boolean specifying whether the error should be raised or handled silently
+        :return: A list of tuples where each tuple contains:
+            - First value: True if entity was created successfully, False if there was an error, None if there was an error and the entity use search identifier
+            - Second value: The original entity (if failed) or the reduced entity with updated identifier (if successful)
+        :return: httpx.HTTPStatusError if there was an HTTP error and should_raise is False
+        """
+        validation_only = request_options["validation_only"]
+        async with self.semaphore:
+            logger.debug(
+                f"{'Validating' if validation_only else 'Upserting'} {len(entities)} of blueprint: {blueprint}"
+            )
+            headers = await self.auth.headers(user_agent_type)
+            response = await self.client.post(
+                f"{self.auth.api_url}/blueprints/{blueprint}/entities/bulk",
+                json={
+                    "entities": [
+                        entity.dict(exclude_unset=True, by_alias=True)
+                        for entity in entities
+                    ]
+                },
+                headers=headers,
+                params={
+                    "upsert": "true",
+                    "merge": str(request_options["merge"]).lower(),
+                    "create_missing_related_entities": str(
+                        request_options["create_missing_related_entities"]
+                    ).lower(),
+                    "validation_only": str(validation_only).lower(),
+                },
+                extensions={"retryable": True},
+            )
+        if response.is_error:
+            logger.error(
+                f"Error {'Validating' if validation_only else 'Upserting'} "
+                f"{len(entities)} entities of "
+                f"blueprint: {blueprint}"
+            )
+            handle_port_status_code(response, should_raise)
+            return httpx.HTTPStatusError(
+                f"HTTP {response.status_code}",
+                request=response.request,
+                response=response,
+            )
+        handle_port_status_code(response, should_raise)
+        result = response.json()
 
-        Returns:
-            Entity: A new entity with only the essential data
+        return self._parse_upsert_entities_batch_response(entities, result)
+
+    def _parse_upsert_entities_batch_response(
+        self,
+        entities: list[Entity],
+        result: BulkUpsertResponse,
+    ) -> list[tuple[bool | None, Entity]]:
         """
-        reduced_entity = Entity(
-            identifier=entity.identifier, blueprint=entity.blueprint
-        )
+        Parse the response from a bulk upsert operation and map it to the original entities.
 
-        # Turning dict typed relations (raw search relations) is required
-        # for us to be able to successfully calculate the participation related entities
-        # and ignore the ones that don't as they weren't upserted
-        reduced_entity.relations = {
-            key: None if isinstance(relation, dict) else relation
-            for key, relation in entity.relations.items()
+        :param entities: The original entities
+        :param result: The response from the bulk upsert operation
+        :return: A list of tuples containing the success status and the entity
+        """
+        index_to_entity = {i: entity for i, entity in enumerate(entities)}
+        successful_entities = {
+            entity_result["index"]: entity_result
+            for entity_result in result.get("entities", [])
         }
-        return reduced_entity
+        error_entities = {error["index"]: error for error in result.get("errors", [])}
+
+        batch_results: list[tuple[bool | None, Entity]] = []
+        for entity_index, original_entity in index_to_entity.items():
+            reduced_entity = self._reduce_entity(original_entity)
+            if entity_index in successful_entities:
+                ocean.metrics.inc_metric(
+                    name=MetricType.OBJECT_COUNT_NAME,
+                    labels=[
+                        ocean.metrics.current_resource_kind(),
+                        MetricPhase.LOAD,
+                        MetricPhase.LoadResult.LOADED,
+                    ],
+                    value=1,
+                )
+                success_entity = successful_entities[entity_index]
+                # Create a copy of the original entity with the new identifier
+                updated_entity = reduced_entity.copy()
+                updated_entity.identifier = success_entity["identifier"]
+                batch_results.append((True, updated_entity))
+            elif entity_index in error_entities:
+                ocean.metrics.inc_metric(
+                    name=MetricType.OBJECT_COUNT_NAME,
+                    labels=[
+                        ocean.metrics.current_resource_kind(),
+                        MetricPhase.LOAD,
+                        MetricPhase.LoadResult.FAILED,
+                    ],
+                    value=1,
+                )
+                error = error_entities[entity_index]
+                if (
+                    error.get("identifier") == "unknown"
+                ):  # when using the search identifier we might not have an actual identifier
+                    batch_results.append((None, reduced_entity))
+                else:
+                    batch_results.append((False, reduced_entity))
+            else:
+                batch_results.append((False, reduced_entity))
+
+        return batch_results
 
-    async def batch_upsert_entities(
+    async def _upsert_entities_batch_individually(
         self,
         entities: list[Entity],
         request_options: RequestOptions,
         user_agent_type: UserAgentType | None = None,
         should_raise: bool = True,
     ) -> list[tuple[bool, Entity]]:
+        entities_results: list[tuple[bool, Entity]] = []
         modified_entities_results = await asyncio.gather(
             *(
                 self.upsert_entity(
@@ -169,17 +320,102 @@ class EntityClientMixin:
             return_exceptions=True,
         )
 
-        entities_results: list[tuple[bool, Entity]] = []
-        for original_entity, result in zip(entities, modified_entities_results):
-            if isinstance(result, Exception) and should_raise:
-                raise result
-            elif isinstance(result, Entity):
-                entities_results.append((True, result))
-            elif result is False:
+        for original_entity, single_result in zip(entities, modified_entities_results):
+            if isinstance(single_result, Exception) and should_raise:
+                raise single_result
+            elif isinstance(single_result, Entity):
+                entities_results.append((True, single_result))
+            elif single_result is False:
                 entities_results.append((False, original_entity))
 
         return entities_results
 
+    async def upsert_entities_in_batches(
+        self,
+        entities: list[Entity],
+        request_options: RequestOptions,
+        user_agent_type: UserAgentType | None = None,
+        should_raise: bool = True,
+    ) -> list[tuple[bool, Entity]]:
+        """
+        This function upserts a list of entities into Port in batches.
+        The batch size is calculated based on both the number of entities and their size.
+        Batches are processed in parallel using asyncio.gather, with concurrency controlled by the semaphore.
+
+        :param entities: A list of Entities to be upserted
+        :param request_options: A dictionary specifying how to upsert the entity
+        :param user_agent_type: a UserAgentType specifying who is preforming the action
+        :param should_raise: A boolean specifying whether the error should be raised or handled silently
+        :return: A list of tuples where each tuple contains:
+            - First value: True if entity was created successfully, False if there was an error
+            - Second value: The reduced entity with updated identifier (if successful) or the original entity (if failed)
+        """
+        entities_results: list[tuple[bool, Entity]] = []
+        blueprint = entities[0].blueprint
+
+        if ocean.config.bulk_upserts_enabled:
+            bulk_size = self.calculate_entities_batch_size(entities)
+            bulks = [
+                entities[i : i + bulk_size] for i in range(0, len(entities), bulk_size)
+            ]
+
+            bulk_results = await asyncio.gather(
+                *(
+                    self.upsert_entities_bulk(
+                        blueprint,
+                        bulk,
+                        request_options,
+                        user_agent_type,
+                        should_raise=should_raise,
+                    )
+                    for bulk in bulks
+                ),
+                return_exceptions=True,
+            )
+
+            for bulk, bulk_result in zip(bulks, bulk_results):
+                if isinstance(bulk_result, httpx.HTTPStatusError) or isinstance(
+                    bulk_result, Exception
+                ):
+                    if should_raise:
+                        raise bulk_result
+                    # If should_raise is False, retry batch in sequential order as a fallback only for 413 errors
+                    if (
+                        isinstance(bulk_result, httpx.HTTPStatusError)
+                        and bulk_result.response.status_code == 413
+                    ):
+                        individual_upsert_results = (
+                            await self._upsert_entities_batch_individually(
+                                bulk, request_options, user_agent_type, should_raise
+                            )
+                        )
+                        entities_results.extend(individual_upsert_results)
+                    else:
+                        # For other errors, mark all entities in the batch as failed
+                        for entity in bulk:
+                            failed_result: tuple[bool, Entity] = (
+                                False,
+                                self._reduce_entity(entity),
+                            )
+                            entities_results.append(failed_result)
+                elif isinstance(bulk_result, list):
+                    for status, entity in bulk_result:
+                        if (
+                            status is not None
+                        ):  # when using the search identifier we might not have an actual identifier
+                            bulk_result_tuple: tuple[bool, Entity] = (
+                                bool(status),
+                                entity,
+                            )
+                            entities_results.append(bulk_result_tuple)
+        else:
+            individual_upsert_results = await self._upsert_entities_batch_individually(
+                entities, request_options, user_agent_type, should_raise
+            )
+            entities_results.extend(individual_upsert_results)
+
+        return entities_results
+
     async def delete_entity(
         self,
         entity: Entity,
@@ -307,3 +543,28 @@ class EntityClientMixin:
                 "rules": [{"combinator": "or", "rules": search_rules}],
             },
         )
+
+    @staticmethod
+    def _reduce_entity(entity: Entity) -> Entity:
+        """
+        Reduces an entity to only keep identifier, blueprint and processed relations.
+        This helps save memory by removing unnecessary data.
+
+        Args:
+            entity: The entity to reduce
+
+        Returns:
+            Entity: A new entity with only the essential data
+        """
+        reduced_entity = Entity(
+            identifier=entity.identifier, blueprint=entity.blueprint
+        )
+
+        # Turning dict typed relations (raw search relations) is required
+        # for us to be able to successfully calculate the participation related entities
+        # and ignore the ones that don't as they weren't upserted
+        reduced_entity.relations = {
+            key: None if isinstance(relation, dict) else relation
+            for key, relation in entity.relations.items()
+        }
+        return reduced_entity

port_ocean/config/dynamic.py

@@ -51,7 +51,7 @@ def default_config_factory(configurations: Any) -> Type[BaseModel]:
             case _:
                 raise ValueError(f"Unknown type: {config.type}")
 
-        default = ... if config.required else None
+        default: Any = ... if config.required else None
         if config.default is not None:
             default = parse_obj_as(field_type, config.default)
         fields[decamelize(config.name)] = (

port_ocean/config/settings.py

@@ -101,6 +101,10 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     caching_storage_mode: Optional[CachingStorageMode] = Field(default=None)
     process_execution_mode: Optional[ProcessExecutionMode] = Field(default=None)
 
+    upsert_entities_batch_max_length: int = 20
+    upsert_entities_batch_max_size_in_bytes: int = 1024 * 1024
+    bulk_upserts_enabled: bool = False
+
     @validator("metrics", pre=True)
     def validate_metrics(cls, v: Any) -> MetricsSettings | dict[str, Any] | None:
         if v is None:

port_ocean/core/handlers/entities_state_applier/port/applier.py

@@ -127,7 +127,7 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
         modified_entities: list[Entity] = []
         upserted_entities: list[tuple[bool, Entity]] = []
 
-        upserted_entities = await self.context.port_client.batch_upsert_entities(
+        upserted_entities = await self.context.port_client.upsert_entities_in_batches(
             entities,
             event.port_app_config.get_port_request_options(),
             user_agent_type,

port_ocean/core/integrations/mixins/sync_raw.py

@@ -33,7 +33,7 @@ from port_ocean.core.ocean_types import (
     CalculationResult,
 )
 from port_ocean.core.utils.utils import resolve_entities_diff, zip_and_sum, gather_and_split_errors_from_results
-from port_ocean.exceptions.core import OceanAbortException
+from port_ocean.exceptions.core import IntegrationSubProcessFailedException, OceanAbortException
 from port_ocean.helpers.metric.metric import MetricResourceKind, SyncState, MetricType, MetricPhase
 from port_ocean.helpers.metric.utils import TimeMetric, TimeMetricWithResourceKind
 from port_ocean.utils.ipc import FileIPC
@@ -626,14 +626,13 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 id = uuid.uuid4()
                 logger.info(f"Starting subprocess with id {id}")
                 file_ipc_map = {
-                    "process_resource": FileIPC(id, "process_resource",([],[])),
+                    "process_resource": FileIPC(id, "process_resource",([],[IntegrationSubProcessFailedException(f"Subprocess failed for {resource.kind} with index {index}")])),
                     "topological_entities": FileIPC(id, "topological_entities",[]),
                 }
                 process = ProcessWrapper(target=self.process_resource_in_subprocess, args=(file_ipc_map,resource,index,user_agent_type))
                 process.start()
                 await process.join_async()
 
-
                 event.entity_topological_sorter.entities.extend(file_ipc_map["topological_entities"].load())
                 return file_ipc_map["process_resource"].load()
 

port_ocean/core/models.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from enum import Enum, StrEnum
-from typing import Any
+from typing import Any, TypedDict
 
 from pydantic import BaseModel
 from pydantic.fields import Field
@@ -67,6 +67,25 @@ class Entity(BaseModel):
         )
 
 
+class EntityBulkResult(TypedDict):
+    identifier: str
+    index: int
+    created: bool
+
+
+class EntityBulkError(TypedDict):
+    identifier: str
+    index: int
+    statusCode: int
+    error: str
+    message: str
+
+
+class BulkUpsertResponse(TypedDict):
+    entities: list[EntityBulkResult]
+    errors: list[EntityBulkError]
+
+
 class BlueprintRelation(BaseModel):
     many: bool
     required: bool

port_ocean/exceptions/core.py

@@ -37,3 +37,7 @@ class IntegrationNotStartedException(BaseOceanException):
 
 class IntegrationRuntimeException(BaseOceanException):
     pass
+
+
+class IntegrationSubProcessFailedException(BaseOceanException):
+    pass

port_ocean/helpers/metric/metric.py

@@ -123,6 +123,7 @@ class Metrics:
         self.registry = prometheus_client.CollectorRegistry()
         if multiprocessing_enabled:
             multiprocess.MultiProcessCollector(self.registry)
+        self.multiprocessing_enabled = multiprocessing_enabled
         self.metrics: dict[str, Gauge] = {}
         self.load_metrics()
         self._integration_version: Optional[str] = None
@@ -213,7 +214,8 @@ class Metrics:
             logger.error(f"Failed to cleanup prometheus metrics: {e}")
 
     def initialize_metrics(self, kind_blockes: list[str]) -> None:
-        self.cleanup_prometheus_metrics()
+        if self.multiprocessing_enabled:
+            self.cleanup_prometheus_metrics()
         for kind in kind_blockes:
             self.set_metric(MetricType.SUCCESS_NAME, [kind, MetricPhase.RESYNC], 0)
             self.set_metric(MetricType.DURATION_NAME, [kind, MetricPhase.RESYNC], 0)

port_ocean/tests/clients/port/mixins/test_entities.py

@@ -1,5 +1,5 @@
-from typing import Any
-from unittest.mock import MagicMock, patch
+from typing import Any, List, Generator
+from unittest.mock import MagicMock, patch, AsyncMock
 
 import pytest
 
@@ -7,50 +7,168 @@ from port_ocean.clients.port.mixins.entities import EntityClientMixin
 from port_ocean.core.models import Entity
 from httpx import ReadTimeout
 
+# Mock the ocean context at module level
+pytestmark = pytest.mark.usefixtures("mock_ocean")
+
 
 errored_entity_identifier: str = "a"
-expected_result_entities = [
+expected_result_entities: List[Entity] = [
     Entity(identifier="b", blueprint="b"),
     Entity(identifier="c", blueprint="c"),
 ]
-all_entities = [
+expected_result_entities_with_exception: List[Entity] = []
+all_entities: List[Entity] = [
     Entity(identifier=errored_entity_identifier, blueprint="a")
 ] + expected_result_entities
 
 
-async def mock_upsert_entity(entity: Entity, *args: Any, **kwargs: Any) -> Entity:
-    if entity.identifier == errored_entity_identifier:
-        raise ReadTimeout("")
-    else:
-        return entity
+@pytest.fixture(autouse=True)
+def mock_ocean() -> Generator[MagicMock, None, None]:
+    with patch("port_ocean.clients.port.mixins.entities.ocean") as mock_ocean:
+        mock_ocean.config.upsert_entities_batch_max_length = 20
+        mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1024 * 1024  # 1MB
+        yield mock_ocean
+
+
+async def mock_upsert_entities_bulk(
+    blueprint: str, entities: list[Entity], *args: Any, **kwargs: Any
+) -> list[tuple[bool | None, Entity]]:
+    results: list[tuple[bool | None, Entity]] = []
+    for entity in entities:
+        if entity.identifier == errored_entity_identifier:
+            results.append((False, entity))
+        else:
+            results.append((True, entity))
+    return results
+
+
+async def mock_exception_upsert_entities_bulk(
+    blueprint: str, entities: list[Entity], *args: Any, **kwargs: Any
+) -> list[tuple[bool | None, Entity]]:
+    for entity in entities:
+        if entity.identifier == errored_entity_identifier:
+            raise ReadTimeout("")
+    return [(True, entity) for entity in entities]
 
 
 @pytest.fixture
 async def entity_client(monkeypatch: Any) -> EntityClientMixin:
-    # Arrange
     entity_client = EntityClientMixin(auth=MagicMock(), client=MagicMock())
-    monkeypatch.setattr(entity_client, "upsert_entity", mock_upsert_entity)
+    mock = AsyncMock()
+    mock.side_effect = mock_upsert_entities_bulk
+    monkeypatch.setattr(entity_client, "upsert_entities_bulk", mock)
 
     return entity_client
 
 
+def test_calculate_entities_batch_size_empty_list(
+    entity_client: EntityClientMixin,
+) -> None:
+    """Test that empty list returns batch size of 1"""
+    assert entity_client.calculate_entities_batch_size([]) == 1
+
+
+def test_calculate_entities_batch_size_small_entities(
+    entity_client: EntityClientMixin,
+) -> None:
+    """Test that small entities return max batch size"""
+    small_entities = [
+        Entity(identifier=f"small_{i}", blueprint="test", properties={"small": "value"})
+        for i in range(30)
+    ]
+    # Small entities should allow max batch size
+    assert entity_client.calculate_entities_batch_size(small_entities) == 20
+
+
+def test_calculate_entities_batch_size_large_entities(
+    entity_client: EntityClientMixin,
+) -> None:
+    """Test that large entities reduce batch size"""
+    large_entities = [
+        Entity(
+            identifier=f"large_{i}",
+            blueprint="test",
+            properties={"large": "x" * (100 * 1024)},  # 100KB per entity
+        )
+        for i in range(30)
+    ]
+    # With 1MB limit and 100KB per entity (plus overhead), should get ~9 entities per batch
+    batch_size = entity_client.calculate_entities_batch_size(large_entities)
+    assert 5 <= batch_size <= 15
+
+
+def test_calculate_entities_batch_size_mixed_entities(
+    entity_client: EntityClientMixin,
+) -> None:
+    """Test that mixed size entities calculate correct batch size"""
+    mixed_entities = [
+        Entity(identifier=f"small_{i}", blueprint="test", properties={"small": "value"})
+        for i in range(10)
+    ] + [
+        Entity(
+            identifier=f"large_{i}",
+            blueprint="test",
+            properties={"large": "x" * (50 * 1024)},  # 50KB per entity
+        )
+        for i in range(10)
+    ]
+    # With 1MB limit and mixed sizes, should get a reasonable batch size
+    batch_size = entity_client.calculate_entities_batch_size(mixed_entities)
+    assert 15 <= batch_size <= 20
+
+
+def test_calculate_entities_batch_size_single_large_entity(
+    entity_client: EntityClientMixin,
+) -> None:
+    """Test that single very large entity returns batch size of 1"""
+    large_entity = Entity(
+        identifier="huge",
+        blueprint="test",
+        properties={"huge": "x" * (2 * 1024 * 1024)},  # 2MB entity
+    )
+    # Even though entity is larger than limit, we return 1 to ensure at least one entity is processed
+    assert entity_client.calculate_entities_batch_size([large_entity]) == 1
+
+
 async def test_batch_upsert_entities_read_timeout_should_raise_false(
     entity_client: EntityClientMixin,
 ) -> None:
     with patch("port_ocean.context.event.event", MagicMock()):
-        result_entities = await entity_client.batch_upsert_entities(
+        result_entities = await entity_client.upsert_entities_in_batches(
             entities=all_entities, request_options=MagicMock(), should_raise=False
         )
-        entities_only = [entity for _, entity in result_entities]
+        # Only get entities that were successfully upserted (status is True)
+        entities_only = [entity for status, entity in result_entities if status is True]
 
         assert entities_only == expected_result_entities
 
 
+async def test_batch_upsert_entities_read_timeout_should_raise_false_with_exception(
+    entity_client: EntityClientMixin,
+    monkeypatch: Any,
+) -> None:
+    with patch("port_ocean.context.event.event", MagicMock()):
+        # Override the mock for this test to use the exception-throwing version
+        mock = AsyncMock(side_effect=mock_exception_upsert_entities_bulk)
+        monkeypatch.setattr(entity_client, "upsert_entities_bulk", mock)
+        result_entities = await entity_client.upsert_entities_in_batches(
+            entities=all_entities, request_options=MagicMock(), should_raise=False
+        )
+        # Only get entities that were successfully upserted (status is True)
+        entities_only = [entity for status, entity in result_entities if status is True]
+
+        assert entities_only == expected_result_entities_with_exception
+
+
 async def test_batch_upsert_entities_read_timeout_should_raise_true(
     entity_client: EntityClientMixin,
+    monkeypatch: Any,
 ) -> None:
     with patch("port_ocean.context.event.event", MagicMock()):
+        # Override the mock for this test to use the exception-throwing version
+        mock = AsyncMock(side_effect=mock_exception_upsert_entities_bulk)
+        monkeypatch.setattr(entity_client, "upsert_entities_bulk", mock)
         with pytest.raises(ReadTimeout):
-            await entity_client.batch_upsert_entities(
+            await entity_client.upsert_entities_in_batches(
                 entities=all_entities, request_options=MagicMock(), should_raise=True
             )

port_ocean/tests/core/conftest.py

@@ -35,24 +35,59 @@ def mock_http_client() -> MagicMock:
     mock_upserted_entities = []
 
     async def post(url: str, *args: Any, **kwargs: Any) -> Response:
-        entity = kwargs.get("json", {})
-        if entity.get("properties", {}).get("mock_is_to_fail", {}):
+        if "/bulk" in url:
+            success_entities = []
+            failed_entities = []
+            entities_body = kwargs.get("json", {})
+            entities = entities_body.get("entities", [])
+            for index, entity in enumerate(entities):
+                if entity.get("properties", {}).get("mock_is_to_fail", False):
+                    failed_entities.append(
+                        {
+                            "identifier": entity.get("identifier"),
+                            "index": index,
+                            "statusCode": 404,
+                            "error": "not_found",
+                            "message": "Entity not found",
+                        }
+                    )
+                else:
+                    mock_upserted_entities.append(
+                        f"{entity.get('identifier')}-{entity.get('blueprint')}"
+                    )
+                    success_entities.append(
+                        (
+                            {
+                                "identifier": entity.get("identifier"),
+                                "index": index,
+                                "created": True,
+                            }
+                        )
+                    )
+
             return Response(
-                404, headers=MagicMock(), json={"ok": False, "error": "not_found"}
+                207,
+                json={"entities": success_entities, "errors": failed_entities},
             )
+        else:
+            entity = kwargs.get("json", {})
+            if entity.get("properties", {}).get("mock_is_to_fail", False):
+                return Response(
+                    404, headers=MagicMock(), json={"ok": False, "error": "not_found"}
+                )
 
-        mock_upserted_entities.append(
-            f"{entity.get('identifier')}-{entity.get('blueprint')}"
-        )
-        return Response(
-            200,
-            json={
-                "entity": {
-                    "identifier": entity.get("identifier"),
-                    "blueprint": entity.get("blueprint"),
-                }
-            },
-        )
+            mock_upserted_entities.append(
+                f"{entity.get('identifier')}-{entity.get('blueprint')}"
+            )
+            return Response(
+                200,
+                json={
+                    "entity": {
+                        "identifier": entity.get("identifier"),
+                        "blueprint": entity.get("blueprint"),
+                    }
+                },
+            )
 
     mock_http_client.post = AsyncMock(side_effect=post)
     return mock_http_client

port_ocean/tests/core/handlers/entities_state_applier/test_applier.py

@@ -1,4 +1,4 @@
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, patch, AsyncMock
 import pytest
 from port_ocean.core.handlers.entities_state_applier.port.applier import (
     HttpEntitiesStateApplier,
@@ -125,33 +125,29 @@ async def test_applier_with_mock_context(
     mock_context: PortOceanContext,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Create an applier using the mock_context fixture
     applier = HttpEntitiesStateApplier(mock_context)
-
-    # Create test entities
     entity = Entity(identifier="test_entity", blueprint="test_blueprint")
 
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
         event.port_app_config = mock_port_app_config
+        event.entity_topological_sorter = Mock()
+
+        mock_blueprint = Mock()
+        mock_blueprint.identifier = "test_blueprint"
+        mock_blueprint.relations = {}
+        mock_get_blueprint = AsyncMock(return_value=mock_blueprint)
+        setattr(mock_ocean.port_client, "get_blueprint", mock_get_blueprint)
 
-        # Test the upsert method with mocked client
-        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
-            mock_post.return_value = Mock(
-                status_code=200,
-                json=lambda: {
-                    "entity": {
-                        "identifier": "test_entity",
-                        "blueprint": "test_blueprint",
-                    }
-                },
-            )
+        mock_ocean.config.upsert_entities_batch_max_length = 100
+        mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1000
 
-            result = await applier.upsert([entity], UserAgentType.exporter)
+        mock_upsert = AsyncMock(return_value=[(True, entity)])
+        setattr(mock_ocean.port_client, "upsert_entities_bulk", mock_upsert)
 
-            # Assert that the post method was called
-            mock_post.assert_called_once()
-            assert len(result) == 1
-            assert result[0].identifier == "test_entity"
+        result = await applier.upsert([entity], UserAgentType.exporter)
+        mock_upsert.assert_called_once()
+        assert len(result) == 1
+        assert result[0].identifier == "test_entity"
 
 
 @pytest.mark.asyncio
@@ -160,32 +156,24 @@ async def test_applier_one_not_upserted(
     mock_context: PortOceanContext,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Create an applier using the mock_context fixture
     applier = HttpEntitiesStateApplier(mock_context)
-
-    # Create test entities
     entity = Entity(identifier="test_entity", blueprint="test_blueprint")
 
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        # Mock the register_entity method
         event.entity_topological_sorter.register_entity = Mock()  # type: ignore
         event.port_app_config = mock_port_app_config
 
-        # Test the upsert method with mocked client
-        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
-            mock_post.return_value = Mock(
-                status_code=404,
-                json=lambda: {"ok": False, "error": "not_found"},
-            )
+        mock_ocean.config.upsert_entities_batch_max_length = 100
+        mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1000
+
+        mock_upsert = AsyncMock(return_value=[(False, entity)])
+        setattr(mock_ocean.port_client, "upsert_entities_bulk", mock_upsert)
 
-            result = await applier.upsert([entity], UserAgentType.exporter)
+        result = await applier.upsert([entity], UserAgentType.exporter)
 
-            # Assert that the post method was called
-            mock_post.assert_called_once()
-            assert len(result) == 0
-            event.entity_topological_sorter.register_entity.assert_called_once_with(
-                entity
-            )
+        mock_upsert.assert_called_once()
+        assert len(result) == 0
+        event.entity_topological_sorter.register_entity.assert_called_once_with(entity)
 
 
 @pytest.mark.asyncio
@@ -194,32 +182,23 @@ async def test_applier_error_upserting(
     mock_context: PortOceanContext,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Create an applier using the mock_context fixture
     applier = HttpEntitiesStateApplier(mock_context)
-
-    # Create test entities
     entity = Entity(identifier="test_entity", blueprint="test_blueprint")
 
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        # Mock the register_entity method
         event.entity_topological_sorter.register_entity = Mock()  # type: ignore
         event.port_app_config = mock_port_app_config
 
-        # Test the upsert method with mocked client
-        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
-            mock_post.return_value = Mock(
-                status_code=404,
-                json=lambda: {"ok": False, "error": "not_found"},
-            )
+        mock_ocean.config.upsert_entities_batch_max_length = 100
+        mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1000
 
-            result = await applier.upsert([entity], UserAgentType.exporter)
+        mock_upsert = AsyncMock(return_value=[(False, entity)])
+        setattr(mock_ocean.port_client, "upsert_entities_bulk", mock_upsert)
 
-            # Assert that the post method was called
-            mock_post.assert_called_once()
-            assert len(result) == 0
-            event.entity_topological_sorter.register_entity.assert_called_once_with(
-                entity
-            )
+        result = await applier.upsert([entity], UserAgentType.exporter)
+        mock_upsert.assert_called_once()
+        assert len(result) == 0
+        event.entity_topological_sorter.register_entity.assert_called_once_with(entity)
 
 
 @pytest.mark.asyncio
@@ -228,31 +207,24 @@ async def test_using_create_entity_helper(
     mock_context: PortOceanContext,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Create the applier with the mock context
     applier = HttpEntitiesStateApplier(mock_context)
-
-    # Create test entities using the helper function
     entity1 = create_entity("entity1", "service", {"related_to": "entity2"}, False)
 
-    # Test that entities were created correctly
     assert entity1.identifier == "entity1"
     assert entity1.blueprint == "service"
     assert entity1.relations == {"related_to": "entity2"}
     assert entity1.properties == {"mock_is_to_fail": False}
 
-    # Test the applier with these entities
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
         event.port_app_config = mock_port_app_config
 
-        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
-            mock_post.return_value = Mock(
-                status_code=200,
-                json=lambda: {
-                    "entity": {"identifier": "entity1", "blueprint": "service"}
-                },
-            )
+        mock_ocean.config.upsert_entities_batch_max_length = 100
+        mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1000
+
+        mock_upsert = AsyncMock(return_value=[(True, entity1)])
+        setattr(mock_ocean.port_client, "upsert_entities_bulk", mock_upsert)
 
-            result = await applier.upsert([entity1], UserAgentType.exporter)
+        result = await applier.upsert([entity1], UserAgentType.exporter)
 
-            mock_post.assert_called_once()
-            assert len(result) == 1
+        mock_upsert.assert_called_once()
+        assert len(result) == 1

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -96,6 +96,10 @@ async def test_sync_raw_mixin_self_dependency(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_ocean: Ocean,
 ) -> None:
+    mock_ocean.config.upsert_entities_batch_max_length = 20
+    mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1024 * 1024
+    mock_ocean.config.bulk_upserts_enabled = True
+
     entities_params = [
         ("entity_1", "service", {"service": "entity_1"}, True),
         ("entity_2", "service", {"service": "entity_2"}, False),
@@ -148,9 +152,13 @@ async def test_sync_raw_mixin_self_dependency(
 
                 assert mock_order_by_entities_dependencies.call_count == 1
                 assert [
-                    call[0][0][0]
+                    call[0][0][0].identifier
                     for call in mock_order_by_entities_dependencies.call_args_list
-                ] == [entity for entity in entities if entity.identifier == "entity_1"]
+                ] == [
+                    entity.identifier
+                    for entity in entities
+                    if entity.identifier == "entity_1"
+                ]
 
                 # Add assertions for actual metrics
                 metrics = mock_ocean.metrics.generate_metrics()
@@ -209,6 +217,10 @@ async def test_sync_raw_mixin_self_dependency(
 async def test_sync_raw_mixin_circular_dependency(
     mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
 ) -> None:
+    mock_ocean.config.upsert_entities_batch_max_length = 20
+    mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1024 * 1024
+    mock_ocean.config.bulk_upserts_enabled = True
+
     entities_params = [
         ("entity_1", "service", {"service": "entity_2"}, True),
         ("entity_2", "service", {"service": "entity_1"}, True),
@@ -284,8 +296,8 @@ async def test_sync_raw_mixin_circular_dependency(
                 assert isinstance(raiesed_error_handle_failed[0].__cause__, CycleError)
                 assert (
                     len(mock_ocean.port_client.client.post.call_args_list)  # type: ignore
-                    / len(entities)
-                    == 2
+                    - len(entities)
+                    == 1
                 )
 
                 # Add assertions for actual metrics
@@ -345,7 +357,10 @@ async def test_sync_raw_mixin_circular_dependency(
 async def test_sync_raw_mixin_dependency(
     mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
 ) -> None:
-    # Create entities with more realistic data
+    mock_ocean.config.upsert_entities_batch_max_length = 20
+    mock_ocean.config.upsert_entities_batch_max_size_in_bytes = 1024 * 1024
+    mock_ocean.config.bulk_upserts_enabled = True
+
     entities_params = [
         ("entity_1", "service", {"service": "entity_3"}, True),
         ("entity_2", "service", {"service": "entity_4"}, True),
@@ -418,17 +433,20 @@ async def test_sync_raw_mixin_dependency(
                 ), "Expected one failed entity callback due to retry logic"
                 assert event.entity_topological_sorter.get_entities.call_count == 1
                 assert len(raiesed_error_handle_failed) == 0
-                assert mock_ocean.port_client.client.post.call_count == 10  # type: ignore
+                assert mock_ocean.port_client.client.post.call_count == 6  # type: ignore
                 assert mock_order_by_entities_dependencies.call_count == 1
 
-                first = mock_ocean.port_client.client.post.call_args_list[0:5]  # type: ignore
-                second = mock_ocean.port_client.client.post.call_args_list[5:10]  # type: ignore
+                result_bulk = mock_ocean.port_client.client.post.call_args_list[0]  # type: ignore
+                result_non_bulk = mock_ocean.port_client.client.post.call_args_list[1:6]  # type: ignore
 
                 assert "-".join(
-                    [call[1].get("json").get("identifier") for call in first]
+                    [
+                        entity.get("identifier")
+                        for entity in result_bulk[1].get("json").get("entities")
+                    ]
                 ) == "-".join([entity.identifier for entity in entities])
                 assert "-".join(
-                    [call[1].get("json").get("identifier") for call in second]
+                    [call[1].get("json").get("identifier") for call in result_non_bulk]
                 ) in (
                     "entity_3-entity_4-entity_1-entity_2-entity_5",
                     "entity_3-entity_4-entity_1-entity_5-entity_2",
@@ -892,6 +910,8 @@ async def test_on_resync_start_hooks_are_called(
         resync_start_called = True
 
     mock_sync_raw_mixin.on_resync_start(on_resync_start)
+    mock_sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([], []))  # type: ignore
+
     mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
     mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
     mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
@@ -922,6 +942,7 @@ async def test_on_resync_complete_hooks_are_called_on_success(
 
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
     mock_ocean.port_client.search_entities.return_value = []  # type: ignore
+    mock_sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([], []))  # type: ignore
     mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
     mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
     mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
@@ -994,6 +1015,7 @@ async def test_multiple_on_resync_start_on_resync_complete_hooks_called_in_order
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete1)
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete2)
     mock_ocean.port_client.search_entities.return_value = []  # type: ignore
+    mock_sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([], []))  # type: ignore
 
     mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
     mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore

port_ocean/tests/log/test_handlers.py

@@ -21,7 +21,8 @@ def test_serialize_record_log_shape() -> None:
     )
     serialized_record = _serialize_record(record)
     assert all(key in serialized_record for key in expected_keys)
-    assert log_message in serialized_record.get("message", None)
+    message = serialized_record.get("message", None)
+    assert message is not None and log_message in message
 
 
 def test_serialize_record_exc_info_single_exception() -> None:

{port_ocean-0.23.4.dist-info → port_ocean-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.23.4
+Version: 0.24.0
 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.23.4.dist-info → port_ocean-0.24.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-integrations/_infra/Dockerfile.Deb,sha256=JMyxgvJxLeo3Vcys-w6m_F6fxfu6JyAcjAMPuXsNQBM,1679
+integrations/_infra/Dockerfile.Deb,sha256=5mSAOr1TaqkfFPTKkB9q9BYIHi4kaR8imfBwJVZuP1M,1679
 integrations/_infra/Dockerfile.alpine,sha256=7E4Sb-8supsCcseerHwTkuzjHZoYcaHIyxiBZ-wewo0,3482
 integrations/_infra/Dockerfile.base.builder,sha256=ESe1PKC6itp_AuXawbLI75k1Kruny6NTANaTinxOgVs,743
 integrations/_infra/Dockerfile.base.runner,sha256=uAcs2IsxrAAUHGXt_qULA5INr-HFguf5a5fCKiqEzbY,384
@@ -59,7 +59,7 @@ port_ocean/clients/port/authentication.py,sha256=r7r8Ag9WuwXy-CmgeOoj-PHbmJAQxhb
 port_ocean/clients/port/client.py,sha256=dv0mxIOde6J-wFi1FXXZkoNPVHrZzY7RSMhNkDD9xgA,3566
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=aMCG4zePsMSMjMLiGrU37h5z5_ElfMzTcTvqvOI5wXY,4683
-port_ocean/clients/port/mixins/entities.py,sha256=-1Gs74z_8eviWItHIpveQhKdA7gnjbqZ3STS4jgGONs,11668
+port_ocean/clients/port/mixins/entities.py,sha256=OMcgJMKruxLBYrHVvzhQmkW6_4QRYi48myjiBd-BTaA,23317
 port_ocean/clients/port/mixins/integrations.py,sha256=s6paomK9bYWW-Tu3y2OIaEGSxsXCHyhapVi4JIhhO64,11162
 port_ocean/clients/port/mixins/migrations.py,sha256=vdL_A_NNUogvzujyaRLIoZEu5vmKDY2BxTjoGP94YzI,1467
 port_ocean/clients/port/mixins/organization.py,sha256=A2cP5V49KnjoAXxjmnm_XGth4ftPSU0qURNfnyUyS_Y,1041
@@ -68,8 +68,8 @@ port_ocean/clients/port/types.py,sha256=nvlgiAq4WH5_F7wQbz_GAWl-faob84LVgIjZ2Ww5
 port_ocean/clients/port/utils.py,sha256=osFyAjw7Y5Qf2uVSqC7_RTCQfijiL1zS74JJM0goxh0,2762
 port_ocean/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/config/base.py,sha256=x1gFbzujrxn7EJudRT81C6eN9WsYAb3vOHwcpcpX8Tc,6370
-port_ocean/config/dynamic.py,sha256=qOFkRoJsn_BW7581omi_AoMxoHqasf_foxDQ_G11_SI,2030
-port_ocean/config/settings.py,sha256=kVXF5_Jr93qW4xDlYXbfehDlQjpv4REjiSAQWePKfYs,6438
+port_ocean/config/dynamic.py,sha256=T0AWE41tjp9fL1sgrTRwNAGlPw6xiakFp-KXWvHtu_4,2035
+port_ocean/config/settings.py,sha256=ls8yae6j7UP_-eIx_eLAwPxSraSsaDJn9osNqz1QUUo,6588
 port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -95,7 +95,7 @@ port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
 port_ocean/core/handlers/entities_state_applier/base.py,sha256=5wHL0icfFAYRPqk8iV_wN49GdJ3aRUtO8tumSxBi4Wo,2268
 port_ocean/core/handlers/entities_state_applier/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=CcrKlFG0eAvUqWit_2SjDrYfTDmMlr4PPSiPBIw7qhM,6367
+port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=QzN8OWgp-i4bRwslnLo5qjS7rt93Stceq9C4FD11Vy4,6372
 port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha256=1zncwCbE-Gej0xaWKlzZgoXxOBe9bgs_YxlZ8QW3NdI,1751
 port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=lyv6xKzhYfd6TioUgR3AVRSJqj7JpAaj1LxxU2xAqeo,1720
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
@@ -121,9 +121,9 @@ port_ocean/core/integrations/mixins/events.py,sha256=2L7P3Jhp8XBqddh2_o9Cn4N261n
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/live_events.py,sha256=8HklZmlyffYY_LeDe8xbt3Tb08rlLkqVhFF-2NQeJP4,4126
 port_ocean/core/integrations/mixins/sync.py,sha256=Vm_898pLKBwfVewtwouDWsXoxcOLicnAy6pzyqqk6U8,4053
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=wZrn0Bz05HmVKDgAJ5LPvP54nSUDpE8uHvjHAYqXVD4,33987
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=4zNsf0QdvsLANhoUTUnf0bNbHIyV7-MqQOYIr0ES85o,34121
 port_ocean/core/integrations/mixins/utils.py,sha256=g1XbC12dswefQ-NpcLSCqFtd_WRp2bTL98jyZ5rRbGk,3444
-port_ocean/core/models.py,sha256=MKfq69zGbFRzo0I2HRDUvSbz_pjrtcFVsD5B4Qwa3fw,2538
+port_ocean/core/models.py,sha256=NYsOBtAqRgmRTb2XYGDW31IxTHSXGRQLOF64apwUZ2Q,2872
 port_ocean/core/ocean_types.py,sha256=4VipWFOHEh_d9LmWewQccwx1p2dtrRYW0YURVgNsAjo,1398
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
 port_ocean/core/utils/utils.py,sha256=XJ6ZZBR5hols19TcX4Bh49ygSNhPt3MLncLR-g41GTA,6858
@@ -133,13 +133,13 @@ port_ocean/exceptions/api.py,sha256=1JcA-H12lhSgolMEA6dM4JMbDrh9sYDcE7oydPSTuK8,
 port_ocean/exceptions/base.py,sha256=uY4DX7fIITDFfemCJDWpaZi3bD51lcANc5swpoNvMJA,46
 port_ocean/exceptions/clients.py,sha256=LKLLs-Zy3caNG85rwxfOw2rMr8qqVV6SHUq4fRCZ99U,180
 port_ocean/exceptions/context.py,sha256=mA8HII6Rl4QxKUz98ppy1zX3kaziaen21h1ZWuU3ADc,372
-port_ocean/exceptions/core.py,sha256=Zmb1m6NnkSPWpAiQA5tgejm3zpDMt1WQEN47OJNo54A,856
+port_ocean/exceptions/core.py,sha256=3LpQrOWdZ-xZ8zm90DmTnFnk0Nms2OgrVIzZBK0Xw5M,931
 port_ocean/exceptions/port_defaults.py,sha256=2a7Koy541KxMan33mU-gbauUxsumG3NT4itVxSpQqfw,666
 port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnqI,197
 port_ocean/exceptions/webhook_processor.py,sha256=yQYazg53Y-ohb7HfViwq1opH_ZUuUdhHSRxcUNveFpI,114
 port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/helpers/async_client.py,sha256=SRlP6o7_FCSY3UHnRlZdezppePVxxOzZ0z861vE3K40,1783
-port_ocean/helpers/metric/metric.py,sha256=mlXH4T_ehShZ0XjGkng3h4MDv7Myw0upwTlpAoC84tA,14395
+port_ocean/helpers/metric/metric.py,sha256=akRZmjzQdY1WMY2O3pDuU0xyW_Tn3XGttG5CkT9_Cbo,14503
 port_ocean/helpers/metric/utils.py,sha256=1lAgrxnZLuR_wUNDyPOPzLrm32b8cDdioob2lvnPQ1A,1619
 port_ocean/helpers/retry.py,sha256=gmS4YxM6N4fboFp7GSgtOzyBJemxs46bnrz4L4rDS6Y,16136
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -158,15 +158,15 @@ port_ocean/tests/cache/test_memory_cache.py,sha256=xlwIOBU0RVLYYJU83l_aoZDzZ6QID
 port_ocean/tests/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/clients/oauth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/clients/oauth/test_oauth_client.py,sha256=2XVMQUalDpiD539Z7_dk5BK_ngXQzsTmb2lNBsfEm9c,3266
-port_ocean/tests/clients/port/mixins/test_entities.py,sha256=Zq_wKTymxJ0R8lHKztvEV6lN__3FZk8uTSIVpKCE6NA,1815
+port_ocean/tests/clients/port/mixins/test_entities.py,sha256=DeWbAQcaxT3LQQf_j9HA5nG7YgsQDvXmgK2aghlG9ug,6619
 port_ocean/tests/clients/port/mixins/test_organization_mixin.py,sha256=zzKYz3h8dl4Z5A2QG_924m0y9U6XTth1XYOfwNrd_24,914
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
-port_ocean/tests/core/conftest.py,sha256=tTOxB8HlCmXgSsXhtPI6xYgdpbpemxfBhA_gBDBuACQ,6115
+port_ocean/tests/core/conftest.py,sha256=7K_M1--wQ08VmiQRB0vo1nst2X00cwsuBS5UfERsnG8,7589
 port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcGsYZ2SCe_PYX5vLYM,5560
-port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=WNg1fWZsXu0MDnz9-ahRiPb_OPofWx7E8wxBx0cyZKs,8946
+port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=eJYXc7AwrV0XRS6HpixwzghjB3pspT5Gxr9twvJE7fk,8290
 port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=8WpMn559Mf0TFWmloRpZrVgr6yWwyA0C4n2lVHCtyq4,13596
 port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=iAwVpr3n3PIkXQLw7hxd-iB_SR_vyfletVXJLOmyz28,12480
-port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=iK-lfu6vk-DBScYm-nLvRzbj0ImbKUN4LfNLXOb8Z3Q,43413
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=E_r_L6Jr6DTPyUP5fn3yQ-MAC3YbpO2AHf690NyLW4g,44447
 port_ocean/tests/core/handlers/port_app_config/test_api.py,sha256=eJZ6SuFBLz71y4ca3DNqKag6d6HUjNJS0aqQPwiLMTI,1999
 port_ocean/tests/core/handlers/port_app_config/test_base.py,sha256=hSh556bJM9zuELwhwnyKSfd9z06WqWXIfe-6hCl5iKI,9799
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
@@ -183,7 +183,7 @@ port_ocean/tests/helpers/integration.py,sha256=_RxS-RHpu11lrbhUXYPZp862HLWx8AoD7
 port_ocean/tests/helpers/ocean_app.py,sha256=N06vcNI1klqdcNFq-PXL5vm77u-hODsOSXnj9p8d1AI,2249
 port_ocean/tests/helpers/port_client.py,sha256=5d6GNr8vNNSOkrz1AdOhxBUKuusr_-UPDP7AVpHasQw,599
 port_ocean/tests/helpers/smoke_test.py,sha256=_9aJJFRfuGJEg2D2YQJVJRmpreS6gEPHHQq8Q01x4aQ,2697
-port_ocean/tests/log/test_handlers.py,sha256=uxgYCEQLP9U5qf-zUN9SgWFogMbYdnBeOVzXZ7E_yFw,2119
+port_ocean/tests/log/test_handlers.py,sha256=x2P2Hd6Cb3sQafIE3TRGltbbHeiFHaiEjwRn9py_03g,2165
 port_ocean/tests/test_metric.py,sha256=gDdeJcqJDQ_o3VrYrW23iZyw2NuUsyATdrygSXhcDuQ,8096
 port_ocean/tests/test_ocean.py,sha256=bsXKGTVEjwLSbR7-qSmI4GZ-EzDo0eBE3TNSMsWzYxM,1502
 port_ocean/tests/test_smoke.py,sha256=uix2uIg_yOm8BHDgHw2hTFPy1fiIyxBGW3ENU_KoFlo,2557
@@ -200,8 +200,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.23.4.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.23.4.dist-info/METADATA,sha256=6drOs6277IC86mO9ZhmdCjVUKy6QL2IqVTi_6x7vyI4,6764
-port_ocean-0.23.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.23.4.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.23.4.dist-info/RECORD,,
+port_ocean-0.24.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.24.0.dist-info/METADATA,sha256=I_Ne_n_R7YjRUyEUR74UJ0u7b5NToTapBpVT0TzFbqU,6764
+port_ocean-0.24.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.24.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.24.0.dist-info/RECORD,,