port-ocean 0.22.11__py3-none-any.whl → 0.23.0__py3-none-any.whl

integrations/_infra/Dockerfile.local

@@ -0,0 +1,41 @@
+ARG BASE_PYTHON_IMAGE=debian:trixie-slim
+# debian:trixie-slim - Python 3.12
+FROM ${BASE_PYTHON_IMAGE}
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends librdkafka-dev python3 \
+    && apt-get clean
+RUN apt-get update \
+    && apt-get install -y \
+        --no-install-recommends \
+        wget \
+        g++ \
+        libssl-dev \
+        autoconf \
+        automake \
+        libtool \
+        curl \
+        librdkafka-dev \
+        python3 \
+        python3-pip \
+        python3-poetry \
+        build-essential\
+        git \
+        python3-venv \
+    && apt-get clean
+
+ARG BUILD_CONTEXT
+
+WORKDIR /app
+
+COPY . .
+RUN rm -rf .venv-docker ${BUILD_CONTEXT}/.venv-docker
+RUN python3 -m venv .venv-docker
+RUN python3 -m venv ${BUILD_CONTEXT}/.venv-docker
+
+
+WORKDIR /app/${BUILD_CONTEXT}
+
+WORKDIR /app
+
+ENTRYPOINT ["./integrations/_infra/entry_local.sh"]

integrations/_infra/entry_local.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+mkdir -p /tmp/prometheus_multiproc_dir
+export PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus_multiproc_dir
+if [ -z "$BUILD_CONTEXT" ]; then
+    echo "BUILD_CONTEXT is not set"
+    exit 1
+fi
+
+if [ ! -d ".venv-docker" ]; then
+    /usr/bin/python3 -m venv .venv-docker
+    source .venv-docker/bin/activate
+    python -m pip install poetry
+    python -m poetry install
+fi
+
+cd $BUILD_CONTEXT
+
+if [ ! -d ".venv-docker" ]; then
+    /usr/bin/python3 -m venv .venv-docker
+    source .venv-docker/bin/activate
+    python -m pip install poetry
+    python -m poetry install
+fi
+source .venv-docker/bin/activate
+python -m pip install -e ../../
+
+ocean sail

port_ocean/__init__.py

@@ -8,4 +8,9 @@ from .run import run  # noqa: E402
 from .version import __integration_version__, __version__  # noqa: E402
 
 
-__all__ = ["Ocean", "run", "__version__", "__integration_version__"]
+__all__ = [
+    "Ocean",
+    "run",
+    "__version__",
+    "__integration_version__",
+]

port_ocean/cache/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from port_ocean.core.models import CachingStorageMode
+
+
+class CacheProvider(ABC):
+    """Base class for cache providers that defines the contract for all cache implementations."""
+
+    STORAGE_TYPE: CachingStorageMode
+
+    @abstractmethod
+    async def get(self, key: str) -> Optional[Any]:
+        """Get a value from the cache."""
+        pass
+
+    @abstractmethod
+    async def set(self, key: str, value: Any) -> None:
+        """Set a value in the cache."""
+        pass
+
+    @abstractmethod
+    async def clear(self) -> None:
+        """Clear all values from the cache."""
+        pass

port_ocean/cache/disk.py

@@ -0,0 +1,61 @@
+import pickle
+from pathlib import Path
+from typing import Any, Optional
+
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.core.models import CachingStorageMode
+
+
+class FailedToReadCacheFileError(FailedToReadCacheError):
+    pass
+
+
+class FailedToWriteCacheFileError(FailedToWriteCacheError):
+    pass
+
+
+class DiskCacheProvider(CacheProvider):
+    STORAGE_TYPE = CachingStorageMode.disk
+
+    def __init__(self, cache_dir: str | None = None) -> None:
+        if cache_dir is None:
+            cache_dir = ".ocean_cache"
+        self._cache_dir = Path(cache_dir)
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_cache_path(self, key: str) -> Path:
+        return self._cache_dir / f"{key}.pkl"
+
+    async def get(self, key: str) -> Optional[Any]:
+        cache_path = self._get_cache_path(key)
+        if not cache_path.exists():
+            return None
+
+        try:
+            with open(cache_path, "rb") as f:
+                return pickle.load(f)
+        except (pickle.PickleError, EOFError) as e:
+            raise FailedToReadCacheFileError(
+                f"Failed to read cache file: {cache_path}: {str(e)}"
+            )
+
+    async def set(self, key: str, value: Any) -> None:
+        cache_path = self._get_cache_path(key)
+        try:
+            with open(cache_path, "wb") as f:
+                pickle.dump(value, f)
+        except (pickle.PickleError, IOError) as e:
+            raise FailedToWriteCacheFileError(
+                f"Failed to write cache file: {cache_path}: {str(e)}"
+            )
+
+    async def clear(self) -> None:
+        try:
+            for cache_file in self._cache_dir.glob("*.pkl"):
+                try:
+                    cache_file.unlink()
+                except OSError:
+                    pass
+        except OSError:
+            pass

port_ocean/cache/errors.py

@@ -0,0 +1,10 @@
+class CacheError(Exception):
+    pass
+
+
+class FailedToReadCacheError(CacheError):
+    pass
+
+
+class FailedToWriteCacheError(CacheError):
+    pass

port_ocean/cache/memory.py

@@ -0,0 +1,36 @@
+from typing import Any, Optional
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.core.models import CachingStorageMode
+
+
+class FailedToReadCacheMemoryError(FailedToReadCacheError):
+    pass
+
+
+class FailedToWriteCacheMemoryError(FailedToWriteCacheError):
+    pass
+
+
+class InMemoryCacheProvider(CacheProvider):
+    CACHE_KEY = "cache"
+    STORAGE_TYPE = CachingStorageMode.memory
+
+    def __init__(self, caching_storage: dict[str, Any] | None = None) -> None:
+        self._storage = caching_storage or {}
+        self._storage[self.CACHE_KEY] = self._storage.get(self.CACHE_KEY, {})
+
+    async def get(self, key: str) -> Optional[Any]:
+        try:
+            return self._storage.get(self.CACHE_KEY, {}).get(key)
+        except KeyError as e:
+            raise FailedToReadCacheMemoryError(f"Failed to read cache: {str(e)}")
+
+    async def set(self, key: str, value: Any) -> None:
+        try:
+            self._storage[self.CACHE_KEY][key] = value
+        except KeyError as e:
+            raise FailedToWriteCacheMemoryError(f"Failed to write cache: {str(e)}")
+
+    async def clear(self) -> None:
+        self._storage[self.CACHE_KEY].clear()

port_ocean/config/settings.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Type, cast
+from typing import Any, Literal, Optional, Type, cast
 
 from pydantic import AnyHttpUrl, Extra, parse_obj_as, parse_raw_as
 from pydantic.class_validators import root_validator, validator
@@ -8,7 +8,12 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanModel, BaseOceanSettings
 from port_ocean.core.event_listener import EventListenerSettingsType
-from port_ocean.core.models import CreatePortResourcesOrigin, Runtime
+from port_ocean.core.models import (
+    CachingStorageMode,
+    CreatePortResourcesOrigin,
+    Runtime,
+    ProcessExecutionMode,
+)
 from port_ocean.utils.misc import get_integration_name, get_spec_file
 
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
@@ -93,6 +98,8 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     )
     max_event_processing_seconds: float = 90.0
     max_wait_seconds_before_shutdown: float = 5.0
+    caching_storage_mode: Optional[CachingStorageMode] = Field(default=None)
+    process_execution_mode: Optional[ProcessExecutionMode] = Field(default=None)
 
     @validator("metrics", pre=True)
     def validate_metrics(cls, v: Any) -> MetricsSettings | dict[str, Any] | None:

port_ocean/core/integrations/mixins/sync_raw.py

@@ -1,12 +1,12 @@
 import asyncio
+import uuid
 from graphlib import CycleError
 import inspect
 import typing
 from typing import Callable, Awaitable, Any
-
+import multiprocessing
 import httpx
 from loguru import logger
-
 from port_ocean.clients.port.types import UserAgentType
 from port_ocean.context.event import TriggerType, event_context, EventType, event
 from port_ocean.context.ocean import ocean
@@ -20,7 +20,7 @@ from port_ocean.core.integrations.mixins.utils import (
     resync_generator_wrapper,
     resync_function_wrapper,
 )
-from port_ocean.core.models import Entity
+from port_ocean.core.models import Entity, ProcessExecutionMode
 from port_ocean.core.ocean_types import (
     RAW_RESULT,
     RESYNC_RESULT,
@@ -33,6 +33,7 @@ from port_ocean.core.utils.utils import resolve_entities_diff, zip_and_sum, gath
 from port_ocean.exceptions.core import OceanAbortException
 from port_ocean.helpers.metric.metric import SyncState, MetricType, MetricPhase
 from port_ocean.helpers.metric.utils import TimeMetric
+from port_ocean.utils.ipc import FileIPC
 
 SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
 
@@ -67,6 +68,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             )
 
         fns = self._collect_resync_functions(resource_config)
+        logger.info(f"Found {len(fns)} resync functions for {resource_config.kind}")
 
         results, errors = await self._execute_resync_tasks(fns, resource_config)
 
@@ -96,8 +98,10 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         results = []
         for task in fns:
             if inspect.isasyncgenfunction(task):
+                logger.info(f"Found async generator function for {resource_config.kind} name: {task.__qualname__}")
                 results.append(resync_generator_wrapper(task, resource_config.kind))
             else:
+                logger.info(f"Found sync function for {resource_config.kind} name: {task.__qualname__}")
                 task = typing.cast(Callable[[str], Awaitable[RAW_RESULT]], task)
                 tasks.append(resync_function_wrapper(task, resource_config.kind))
 
@@ -264,7 +268,6 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     objects_diff[0].entity_selector_diff.passed, user_agent_type
                     )
 
-
         return CalculationResult(
             number_of_transformed_entities=len(objects_diff[0].entity_selector_diff.passed),
             entity_selector_diff=objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
@@ -341,8 +344,8 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         user_agent_type,
                         send_raw_data_examples_amount=send_raw_data_examples_amount
                     )
-                    errors.extend(calculation_result.errors)
                     passed_entities.extend(calculation_result.entity_selector_diff.passed)
+                    errors.extend(calculation_result.errors)
                     number_of_transformed_entities += calculation_result.number_of_transformed_entities
             except* OceanAbortException as error:
                 ocean.metrics.sync_state = SyncState.FAILED
@@ -352,6 +355,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             f"Finished registering kind: {resource_config.kind}-{resource.resource.index} ,{len(passed_entities)} entities out of {number_of_raw_results} raw results"
         )
 
+
         ocean.metrics.set_metric(
             name=MetricType.SUCCESS_NAME,
             labels=[ocean.metrics.current_resource_kind(), MetricPhase.RESYNC],
@@ -581,6 +585,72 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 for entity in event.entity_topological_sorter.get_entities(False):
                     await self.entities_state_applier.context.port_client.upsert_entity(entity,event.port_app_config.get_port_request_options(),user_agent_type,should_raise=False)
 
+    def process_resource_in_subprocess(self,
+        file_ipc_map: dict[str, FileIPC],
+        resource: ResourceConfig,
+        index: int,
+        user_agent_type: UserAgentType,
+    ) -> None:
+        logger.info(f"process started successfully for {resource.kind} with index {index}")
+
+        async def process_resource_task() -> None:
+            result = await self._process_resource(
+                resource, index, user_agent_type
+            )
+            file_ipc_map["process_resource"].save(result)
+            file_ipc_map["topological_entities"].save(
+                event.entity_topological_sorter.entities
+            )
+
+        asyncio.run(process_resource_task())
+        logger.info(f"Process finished for {resource.kind} with index {index}")
+
+    async def process_resource(self, resource: ResourceConfig, index: int, user_agent_type: UserAgentType) -> tuple[list[Entity], list[Exception]]:
+            if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+                id = uuid.uuid4()
+                logger.info(f"Starting subprocess with id {id}")
+                file_ipc_map = {
+                    "process_resource": FileIPC(id, "process_resource",([],[])),
+                    "topological_entities": FileIPC(id, "topological_entities",[]),
+                }
+                process = multiprocessing.Process(target=self.process_resource_in_subprocess, args=(file_ipc_map,resource,index,user_agent_type))
+                process.start()
+                process.join()
+                if process.exitcode != 0:
+                    logger.error(f"Process {id} failed with exit code {process.exitcode}")
+                event.entity_topological_sorter.entities.extend(file_ipc_map["topological_entities"].load())
+                return file_ipc_map["process_resource"].load()
+
+            else:
+                return await self._process_resource(resource,index,user_agent_type)
+
+    async def _process_resource(self,resource: ResourceConfig, index: int, user_agent_type: UserAgentType)-> tuple[list[Entity], list[Exception]]:
+        # create resource context per resource kind, so resync method could have access to the resource
+        # config as we might have multiple resources in the same event
+        async with resource_context(resource,index):
+            resource_kind_id = f"{resource.kind}-{index}"
+            ocean.metrics.sync_state = SyncState.SYNCING
+            task = asyncio.create_task(
+                self._register_in_batches(resource, user_agent_type)
+            )
+            event.on_abort(lambda: task.cancel())
+            kind_results: tuple[list[Entity], list[Exception]] = await task
+            ocean.metrics.set_metric(
+                name=MetricType.OBJECT_COUNT_NAME,
+                labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.LOADED],
+                value=len(kind_results[0])
+            )
+
+            if ocean.metrics.sync_state != SyncState.FAILED:
+                ocean.metrics.sync_state = SyncState.COMPLETED
+
+            await ocean.metrics.send_metrics_to_webhook(
+                kind=resource_kind_id
+            )
+            # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
+
+            return kind_results
+
     @TimeMetric(MetricPhase.RESYNC)
     async def sync_raw_all(
         self,
@@ -619,6 +689,9 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             ocean.metrics.initialize_metrics(kinds)
             # await ocean.metrics.report_sync_metrics(kinds=kinds) # TODO: uncomment this when end points are ready
 
+            # Clear cache
+            await ocean.app.cache_provider.clear()
+
             # Execute resync_start hooks
             for resync_start_fn in self.event_strategy["resync_start"]:
                 await resync_start_fn()
@@ -637,32 +710,13 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 
-
+            multiprocessing.set_start_method('fork', True)
             try:
                 for index,resource in enumerate(app_config.resources):
-                    # create resource context per resource kind, so resync method could have access to the resource
-                    # config as we might have multiple resources in the same event
-                    async with resource_context(resource,index):
-                        resource_kind_id = f"{resource.kind}-{index}"
-                        ocean.metrics.sync_state = SyncState.SYNCING
-                        # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
-
-                        task = asyncio.create_task(
-                            self._register_in_batches(resource, user_agent_type)
-                        )
 
-                        event.on_abort(lambda: task.cancel())
-                        kind_results: tuple[list[Entity], list[Exception]] = await task
+                    logger.info(f"Starting processing resource {resource.kind} with index {index}")
 
-                        creation_results.append(kind_results)
-
-                        if ocean.metrics.sync_state != SyncState.FAILED:
-                            ocean.metrics.sync_state = SyncState.COMPLETED
-
-                        await ocean.metrics.send_metrics_to_webhook(
-                            kind=resource_kind_id
-                        )
-                        # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
+                    creation_results.append(await self.process_resource(resource,index,user_agent_type))
 
                 await self.sort_and_upsert_failed_entities(user_agent_type)
 
@@ -718,3 +772,5 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         logger.info("Finished executing resync_complete hooks")
 
                     return True
+            finally:
+                await ocean.app.cache_provider.clear()

port_ocean/core/integrations/mixins/utils.py

@@ -22,9 +22,9 @@ def resync_error_handling() -> Generator[None, None, None]:
     try:
         yield
     except RawObjectValidationException as error:
-        raise OceanAbortException(
-            f"Failed to validate raw data for returned data from resync function, error: {error}"
-        ) from error
+        err_msg = f"Failed to validate raw data for returned data from resync function, error: {error}"
+        logger.exception(err_msg)
+        raise OceanAbortException(err_msg) from error
     except StopAsyncIteration:
         raise
     except Exception as error:

port_ocean/core/models.py

@@ -11,6 +11,16 @@ class CreatePortResourcesOrigin(StrEnum):
     Port = "Port"
 
 
+class ProcessExecutionMode(StrEnum):
+    multi_process = "multi_process"
+    single_process = "single_process"
+
+
+class CachingStorageMode(StrEnum):
+    disk = "disk"
+    memory = "memory"
+
+
 class Runtime(Enum):
     Saas = "Saas"
     OnPrem = "OnPrem"

port_ocean/helpers/metric/metric.py

@@ -10,6 +10,7 @@ from prometheus_client import Gauge
 import prometheus_client.openmetrics
 import prometheus_client.openmetrics.exposition
 import prometheus_client.parser
+from prometheus_client import multiprocess
 
 if TYPE_CHECKING:
     from port_ocean.config.settings import MetricsSettings, IntegrationSettings
@@ -108,11 +109,14 @@ class Metrics:
         metrics_settings: "MetricsSettings",
         integration_configuration: "IntegrationSettings",
         port_client: "PortClient",
+        multiprocessing_enabled: bool = False,
     ) -> None:
         self.metrics_settings = metrics_settings
         self.integration_configuration = integration_configuration
         self.port_client = port_client
         self.registry = prometheus_client.CollectorRegistry()
+        if multiprocessing_enabled:
+            multiprocess.MultiProcessCollector(self.registry)
         self.metrics: dict[str, Gauge] = {}
         self.load_metrics()
         self._integration_version: Optional[str] = None

port_ocean/ocean.py

@@ -4,6 +4,10 @@ from contextlib import asynccontextmanager
 import threading
 from typing import Any, AsyncIterator, Callable, Dict, Type
 
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.disk import DiskCacheProvider
+from port_ocean.cache.memory import InMemoryCacheProvider
+from port_ocean.core.models import ProcessExecutionMode
 import port_ocean.helpers.metric.metric
 
 from fastapi import FastAPI, APIRouter
@@ -66,11 +70,16 @@ class Ocean:
             integration_type=self.config.integration.type,
             integration_version=__integration_version__,
         )
-
+        self.cache_provider: CacheProvider = self._get_caching_provider()
+        self.process_execution_mode: ProcessExecutionMode = (
+            self._get_process_execution_mode()
+        )
         self.metrics = port_ocean.helpers.metric.metric.Metrics(
             metrics_settings=self.config.metrics,
             integration_configuration=self.config.integration,
             port_client=self.port_client,
+            multiprocessing_enabled=self.process_execution_mode
+            == ProcessExecutionMode.multi_process,
         )
 
         self.webhook_manager = LiveEventsProcessorManager(
@@ -90,6 +99,24 @@ class Ocean:
 
         self.app_initialized = False
 
+    def _get_process_execution_mode(self) -> ProcessExecutionMode:
+        if self.config.process_execution_mode:
+            return self.config.process_execution_mode
+        return ProcessExecutionMode.single_process
+
+    def _get_caching_provider(self) -> CacheProvider:
+        if self.config.caching_storage_mode:
+            caching_type_to_provider = {
+                DiskCacheProvider.STORAGE_TYPE: DiskCacheProvider,
+                InMemoryCacheProvider.STORAGE_TYPE: InMemoryCacheProvider,
+            }
+            if self.config.caching_storage_mode in caching_type_to_provider:
+                return caching_type_to_provider[self.config.caching_storage_mode]()
+
+        if self.config.process_execution_mode == ProcessExecutionMode.multi_process:
+            return DiskCacheProvider()
+        return InMemoryCacheProvider()
+
     def is_saas(self) -> bool:
         return self.config.runtime.is_saas_runtime
 

port_ocean/run.py

@@ -21,7 +21,6 @@ def _get_default_config_factory() -> None | Type[BaseModel]:
     config_factory = None
     if spec is not None:
         config_factory = default_config_factory(spec.get("configurations", []))
-
     return config_factory
 
 

port_ocean/tests/cache/__init__.py

@@ -0,0 +1 @@
+"""Tests for cache providers."""

port_ocean/tests/cache/test_disk_cache.py

@@ -0,0 +1,92 @@
+import os
+import pytest
+from pathlib import Path
+
+from port_ocean.cache.disk import (
+    DiskCacheProvider,
+    FailedToReadCacheFileError,
+    FailedToWriteCacheFileError,
+)
+
+
+@pytest.fixture
+def disk_cache(tmp_path: Path) -> DiskCacheProvider:
+    """Fixture that provides a DiskCacheProvider with a temporary directory."""
+    return DiskCacheProvider(cache_dir=str(tmp_path))
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_set_get(disk_cache: DiskCacheProvider) -> None:
+    """Test setting and getting values from disk cache."""
+    # Test basic set/get
+    await disk_cache.set("test_key", "test_value")
+    assert await disk_cache.get("test_key") == "test_value"
+
+    # Test with different types
+    test_data = {
+        "string": "hello",
+        "int": 42,
+        "float": 3.14,
+        "list": [1, 2, 3],
+        "dict": {"a": 1, "b": 2},
+    }
+
+    for key, value in test_data.items():
+        await disk_cache.set(key, value)
+        assert await disk_cache.get(key) == value
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_clear(disk_cache: DiskCacheProvider) -> None:
+    """Test clearing all values from disk cache."""
+    # Add multiple values
+    for i in range(5):
+        await disk_cache.set(f"key_{i}", f"value_{i}")
+
+    # Verify values exist
+    for i in range(5):
+        assert await disk_cache.get(f"key_{i}") == f"value_{i}"
+
+    # Clear cache
+    await disk_cache.clear()
+
+    # Verify all values are gone
+    for i in range(5):
+        assert await disk_cache.get(f"key_{i}") is None
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_nonexistent_key(disk_cache: DiskCacheProvider) -> None:
+    """Test getting a nonexistent key from disk cache."""
+    assert await disk_cache.get("nonexistent_key") is None
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_corrupted_file(
+    disk_cache: DiskCacheProvider, tmp_path: Path
+) -> None:
+    """Test handling of corrupted cache files."""
+    # Create a corrupted pickle file
+    cache_path = tmp_path / "test_key.pkl"
+    with open(cache_path, "wb") as f:
+        f.write(b"invalid pickle data")
+
+    # Attempting to read should raise FailedToReadCacheFileError
+    with pytest.raises(FailedToReadCacheFileError):
+        await disk_cache.get("test_key")
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_write_error(
+    disk_cache: DiskCacheProvider, tmp_path: Path
+) -> None:
+    """Test handling of write errors."""
+    # Make the cache directory read-only
+    os.chmod(tmp_path, 0o444)
+
+    # Attempting to write should raise FailedToWriteCacheFileError
+    with pytest.raises(FailedToWriteCacheFileError):
+        await disk_cache.set("test_key", "test_value")
+
+    # Restore permissions
+    os.chmod(tmp_path, 0o755)

port_ocean/tests/cache/test_memory_cache.py

@@ -0,0 +1,59 @@
+import pytest
+
+from port_ocean.cache.memory import (
+    InMemoryCacheProvider,
+)
+
+
+@pytest.fixture
+def memory_cache() -> InMemoryCacheProvider:
+    """Fixture that provides an InMemoryCacheProvider."""
+    return InMemoryCacheProvider()
+
+
+@pytest.mark.asyncio
+async def test_memory_cache_set_get(memory_cache: InMemoryCacheProvider) -> None:
+    """Test setting and getting values from memory cache."""
+    # Test basic set/get
+    await memory_cache.set("test_key", "test_value")
+    assert await memory_cache.get("test_key") == "test_value"
+
+    # Test with different types
+    test_data = {
+        "string": "hello",
+        "int": 42,
+        "float": 3.14,
+        "list": [1, 2, 3],
+        "dict": {"a": 1, "b": 2},
+    }
+
+    for key, value in test_data.items():
+        await memory_cache.set(key, value)
+        assert await memory_cache.get(key) == value
+
+
+@pytest.mark.asyncio
+async def test_memory_cache_clear(memory_cache: InMemoryCacheProvider) -> None:
+    """Test clearing all values from memory cache."""
+    # Add multiple values
+    for i in range(5):
+        await memory_cache.set(f"key_{i}", f"value_{i}")
+
+    # Verify values exist
+    for i in range(5):
+        assert await memory_cache.get(f"key_{i}") == f"value_{i}"
+
+    # Clear cache
+    await memory_cache.clear()
+
+    # Verify all values are gone
+    for i in range(5):
+        assert await memory_cache.get(f"key_{i}") is None
+
+
+@pytest.mark.asyncio
+async def test_memory_cache_nonexistent_key(
+    memory_cache: InMemoryCacheProvider,
+) -> None:
+    """Test getting a nonexistent key from memory cache."""
+    assert await memory_cache.get("nonexistent_key") is None

port_ocean/tests/core/conftest.py

@@ -6,6 +6,7 @@ import pytest
 from httpx import Response
 
 from port_ocean.clients.port.client import PortClient
+from port_ocean.config.settings import IntegrationSettings, MetricsSettings
 from port_ocean.context.event import EventContext
 from port_ocean.context.ocean import PortOceanContext, ocean
 from port_ocean.core.handlers.entities_state_applier.port.applier import (
@@ -22,8 +23,10 @@ from port_ocean.core.handlers.port_app_config.models import (
     ResourceConfig,
     Selector,
 )
-from port_ocean.core.models import Entity
+from port_ocean.core.models import Entity, ProcessExecutionMode
+from port_ocean.helpers.metric.metric import Metrics
 from port_ocean.ocean import Ocean
+from port_ocean.cache.memory import InMemoryCacheProvider
 
 
 @pytest.fixture
@@ -83,8 +86,15 @@ def mock_ocean(mock_port_client: PortClient) -> Ocean:
         ocean_mock.config.port = MagicMock()
         ocean_mock.config.port.port_app_config_cache_ttl = 60
         ocean_mock.port_client = mock_port_client
-        ocean_mock.metrics = MagicMock()
-        ocean_mock.metrics.flush = AsyncMock()
+        ocean_mock.process_execution_mode = ProcessExecutionMode.single_process
+        ocean_mock.cache_provider = InMemoryCacheProvider()
+        metrics_settings = MetricsSettings(enabled=True)
+        integration_settings = IntegrationSettings(type="test", identifier="test")
+        ocean_mock.metrics = Metrics(
+            metrics_settings=metrics_settings,
+            integration_configuration=integration_settings,
+            port_client=mock_port_client,
+        )
 
         return ocean_mock
 

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

@@ -1,7 +1,6 @@
 from graphlib import CycleError
 from typing import Any, AsyncGenerator
 
-from port_ocean.clients.port.client import PortClient
 from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
 from port_ocean.exceptions.core import OceanAbortException
 import pytest
@@ -25,8 +24,6 @@ from port_ocean.clients.port.types import UserAgentType
 from dataclasses import dataclass
 from typing import List, Optional
 from port_ocean.tests.core.conftest import create_entity, no_op_event_context
-from port_ocean.helpers.metric.metric import Metrics
-from port_ocean.config.settings import MetricsSettings, IntegrationSettings
 
 
 @pytest.fixture
@@ -94,29 +91,6 @@ def mock_sync_raw_mixin_with_jq_processor(
     return mock_sync_raw_mixin
 
 
-@pytest.fixture
-def mock_ocean(mock_port_client: PortClient) -> Ocean:
-    with patch("port_ocean.ocean.Ocean.__init__", return_value=None):
-        ocean_mock = Ocean(
-            MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
-        )
-        ocean_mock.config = MagicMock()
-        ocean_mock.config.port = MagicMock()
-        ocean_mock.config.port.port_app_config_cache_ttl = 60
-        ocean_mock.port_client = mock_port_client
-
-        # Create real metrics instance
-        metrics_settings = MetricsSettings(enabled=True)
-        integration_settings = IntegrationSettings(type="test", identifier="test")
-        ocean_mock.metrics = Metrics(
-            metrics_settings=metrics_settings,
-            integration_configuration=integration_settings,
-            port_client=mock_port_client,
-        )
-
-        return ocean_mock
-
-
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_self_dependency(
     mock_sync_raw_mixin: SyncRawMixin,
@@ -213,7 +187,7 @@ async def test_sync_raw_mixin_self_dependency(
                             metric["metrics"]["phase"]["load"]["object_count_type"][
                                 "loaded"
                             ]["object_count"]
-                            == 1
+                            == 2
                         )
 
                         # Verify success
@@ -341,7 +315,7 @@ async def test_sync_raw_mixin_circular_dependency(
                             metric["metrics"]["phase"]["load"]["object_count_type"][
                                 "loaded"
                             ]["object_count"]
-                            == 0
+                            == 2
                         )
 
                         # Verify success

port_ocean/tests/utils/test_cache.py

@@ -1,19 +1,25 @@
 from typing import Any
 import asyncio
-from port_ocean.utils import cache  # Import the module where 'event' is used
+from port_ocean.utils import cache
 import pytest
-from dataclasses import dataclass, field
 from typing import AsyncGenerator, AsyncIterator, List, TypeVar
+from unittest.mock import AsyncMock
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.cache.memory import InMemoryCacheProvider
 
 
-@dataclass
-class EventContext:
-    attributes: dict[str, Any] = field(default_factory=dict)
+@pytest.fixture
+def memory_cache() -> InMemoryCacheProvider:
+    return InMemoryCacheProvider()
 
 
 @pytest.fixture
-def event() -> EventContext:
-    return EventContext()
+def mock_ocean(memory_cache: InMemoryCacheProvider) -> Any:
+    return type(
+        "MockOcean",
+        (),
+        {"app": type("MockApp", (), {"cache_provider": memory_cache})()},
+    )()
 
 
 T = TypeVar("T")
@@ -27,8 +33,8 @@ async def collect_iterator_results(iterator: AsyncIterator[List[T]]) -> List[T]:
 
 
 @pytest.mark.asyncio
-async def test_cache_iterator_result(event: EventContext, monkeypatch: Any) -> None:
-    monkeypatch.setattr(cache, "event", event)
+async def test_cache_iterator_result(mock_ocean: Any, monkeypatch: Any) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -55,9 +61,9 @@ async def test_cache_iterator_result(event: EventContext, monkeypatch: Any) -> N
 
 @pytest.mark.asyncio
 async def test_cache_iterator_result_with_kwargs(
-    event: EventContext, monkeypatch: Any
+    mock_ocean: Any, monkeypatch: Any
 ) -> None:
-    monkeypatch.setattr(cache, "event", event)
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -83,10 +89,16 @@ async def test_cache_iterator_result_with_kwargs(
 
 
 @pytest.mark.asyncio
-async def test_cache_iterator_result_no_cache(
-    event: EventContext, monkeypatch: Any
+async def test_cache_iterator_result_cache_errors(
+    mock_ocean: Any, monkeypatch: Any
 ) -> None:
-    monkeypatch.setattr(cache, "event", event)
+    # Create a mock cache provider that raises errors
+    mock_cache_provider = AsyncMock()
+    mock_cache_provider.get.side_effect = FailedToReadCacheError("fail read")
+    mock_cache_provider.set.side_effect = FailedToWriteCacheError("fail write")
+
+    mock_ocean.app.cache_provider = mock_cache_provider
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -98,20 +110,20 @@ async def test_cache_iterator_result_no_cache(
             await asyncio.sleep(0.1)
             yield [i]
 
+    # First call should execute the function since cache read fails
     result1 = await collect_iterator_results(sample_iterator(3))
     assert result1 == [0, 1, 2]
     assert call_count == 1
 
-    event.attributes.clear()
-
+    # Second call should also execute the function since cache read fails
     result2 = await collect_iterator_results(sample_iterator(3))
     assert result2 == [0, 1, 2]
     assert call_count == 2
 
 
 @pytest.mark.asyncio
-async def test_cache_coroutine_result(event: EventContext, monkeypatch: Any) -> None:
-    monkeypatch.setattr(cache, "event", event)
+async def test_cache_coroutine_result(mock_ocean: Any, monkeypatch: Any) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -137,9 +149,9 @@ async def test_cache_coroutine_result(event: EventContext, monkeypatch: Any) ->
 
 @pytest.mark.asyncio
 async def test_cache_coroutine_result_with_kwargs(
-    event: EventContext, monkeypatch: Any
+    mock_ocean: Any, monkeypatch: Any
 ) -> None:
-    monkeypatch.setattr(cache, "event", event)
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -164,10 +176,16 @@ async def test_cache_coroutine_result_with_kwargs(
 
 
 @pytest.mark.asyncio
-async def test_cache_coroutine_result_no_cache(
-    event: EventContext, monkeypatch: Any
+async def test_cache_coroutine_result_cache_errors(
+    mock_ocean: Any, monkeypatch: Any
 ) -> None:
-    monkeypatch.setattr(cache, "event", event)
+    # Create a mock cache provider that raises errors
+    mock_cache_provider = AsyncMock()
+    mock_cache_provider.get.side_effect = FailedToReadCacheError("fail read")
+    mock_cache_provider.set.side_effect = FailedToWriteCacheError("fail write")
+
+    mock_ocean.app.cache_provider = mock_cache_provider
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
 
     call_count = 0
 
@@ -178,12 +196,79 @@ async def test_cache_coroutine_result_no_cache(
         await asyncio.sleep(0.1)
         return x * 2
 
+    # First call should execute the function since cache read fails
     result1 = await sample_coroutine(2)
     assert result1 == 4
     assert call_count == 1
 
-    event.attributes.clear()
-
+    # Second call should also execute the function since cache read fails
     result2 = await sample_coroutine(2)
     assert result2 == 4
     assert call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_cache_failures_dont_affect_execution(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    """Test that cache failures (both read and write) don't affect the decorated function execution."""
+    # Create a mock cache provider that raises errors
+    mock_cache_provider = AsyncMock()
+    mock_cache_provider.get.side_effect = FailedToReadCacheError("fail read")
+    mock_cache_provider.set.side_effect = FailedToWriteCacheError("fail write")
+
+    mock_ocean.app.cache_provider = mock_cache_provider
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    # Test both iterator and coroutine decorators
+    iterator_call_count = 0
+    coroutine_call_count = 0
+
+    @cache.cache_iterator_result()
+    async def sample_iterator(x: int) -> AsyncGenerator[List[int], None]:
+        nonlocal iterator_call_count
+        iterator_call_count += 1
+        for i in range(x):
+            await asyncio.sleep(0.1)
+            yield [i]
+
+    @cache.cache_coroutine_result()
+    async def sample_coroutine(x: int) -> int:
+        nonlocal coroutine_call_count
+        coroutine_call_count += 1
+        await asyncio.sleep(0.1)
+        return x * 2
+
+    # Test iterator function
+    # First call - should execute function (cache read fails)
+    result1 = await collect_iterator_results(sample_iterator(3))
+    assert result1 == [0, 1, 2]
+    assert iterator_call_count == 1
+    assert mock_cache_provider.get.call_count == 1
+    assert mock_cache_provider.set.call_count == 1
+
+    # Second call - should execute function again (cache read fails)
+    result2 = await collect_iterator_results(sample_iterator(3))
+    assert result2 == [0, 1, 2]
+    assert iterator_call_count == 2
+    assert mock_cache_provider.get.call_count == 2
+    assert mock_cache_provider.set.call_count == 2
+
+    # Test coroutine function
+    # First call - should execute function (cache read fails)
+    result3 = await sample_coroutine(4)
+    assert result3 == 8
+    assert coroutine_call_count == 1
+    assert mock_cache_provider.get.call_count == 3
+    assert mock_cache_provider.set.call_count == 3
+
+    # Second call - should execute function again (cache read fails)
+    result4 = await sample_coroutine(4)
+    assert result4 == 8
+    assert coroutine_call_count == 2
+    assert mock_cache_provider.get.call_count == 4
+    assert mock_cache_provider.set.call_count == 4
+
+    # Verify that both read and write errors were raised
+    assert isinstance(mock_cache_provider.get.side_effect, FailedToReadCacheError)
+    assert isinstance(mock_cache_provider.set.side_effect, FailedToWriteCacheError)

port_ocean/utils/cache.py

@@ -1,7 +1,10 @@
 import functools
 import hashlib
+import base64
 from typing import Callable, AsyncIterator, Awaitable, Any
-from port_ocean.context.event import event
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.context.ocean import ocean
+from loguru import logger
 
 AsyncIteratorCallable = Callable[..., AsyncIterator[list[Any]]]
 AsyncCallable = Callable[..., Awaitable[Any]]
@@ -12,15 +15,18 @@ def hash_func(function_name: str, *args: Any, **kwargs: Any) -> str:
     kwargs_str = str(kwargs)
     concatenated_string = args_str + kwargs_str
     hash_object = hashlib.sha256(concatenated_string.encode())
-    return f"{function_name}_{hash_object.hexdigest()}"
+    short_hash = base64.urlsafe_b64encode(hash_object.digest()[:8]).decode("ascii")
+    short_hash = short_hash.rstrip("=").replace("-", "_").replace("+", "_")
+    return f"{function_name}_{short_hash}"
 
 
 def cache_iterator_result() -> Callable[[AsyncIteratorCallable], AsyncIteratorCallable]:
     """
     This decorator caches the results of an async iterator function. It checks if the result is already in the cache
-    and if not, it fetches the all the data and caches it at ocean.attributes cache the end of the iteration.
+    and if not, it fetches the all the data and caches it at the end of the iteration.
 
     The cache will be stored in the scope of the running event and will be removed when the event is finished.
+    If a database is configured, the cache will also be stored in the database.
 
     For example, you can use this to cache data coming back from the third-party API to avoid making the same request
     multiple times for each kind.
@@ -39,13 +45,15 @@ def cache_iterator_result() -> Callable[[AsyncIteratorCallable], AsyncIteratorCa
     def decorator(func: AsyncIteratorCallable) -> AsyncIteratorCallable:
         @functools.wraps(func)
         async def wrapper(*args: Any, **kwargs: Any) -> Any:
-            # Create Hash key from function name, args and kwargs
             cache_key = hash_func(func.__name__, *args, **kwargs)
 
             # Check if the result is already in the cache
-            if cache := event.attributes.get(cache_key):
-                yield cache
-                return
+            try:
+                if cache := await ocean.app.cache_provider.get(cache_key):
+                    yield cache
+                    return
+            except FailedToReadCacheError as e:
+                logger.warning(f"Failed to read cache for {cache_key}: {str(e)}")
 
             # If not in cache, fetch the data
             cached_results = list()
@@ -54,7 +62,13 @@ def cache_iterator_result() -> Callable[[AsyncIteratorCallable], AsyncIteratorCa
                 yield result
 
             # Cache the results
-            event.attributes[cache_key] = cached_results
+            try:
+                await ocean.app.cache_provider.set(
+                    cache_key,
+                    cached_results,
+                )
+            except FailedToWriteCacheError as e:
+                logger.warning(f"Failed to write cache for {cache_key}: {str(e)}")
             return
 
         return wrapper
@@ -71,6 +85,7 @@ def cache_coroutine_result() -> Callable[[AsyncCallable], AsyncCallable]:
 
     The cache is stored in the scope of the running event and is
     removed when the event is finished.
+    If a database is configured, the cache will also be stored in the database.
 
     Usage:
     ```python
@@ -84,12 +99,20 @@ def cache_coroutine_result() -> Callable[[AsyncCallable], AsyncCallable]:
         @functools.wraps(func)
         async def wrapper(*args: Any, **kwargs: Any) -> Any:
             cache_key = hash_func(func.__name__, *args, **kwargs)
-
-            if cache := event.attributes.get(cache_key):
-                return cache
+            try:
+                if cache := await ocean.app.cache_provider.get(cache_key):
+                    return cache
+            except FailedToReadCacheError as e:
+                logger.warning(f"Failed to read cache for {cache_key}: {str(e)}")
 
             result = await func(*args, **kwargs)
-            event.attributes[cache_key] = result
+            try:
+                await ocean.app.cache_provider.set(
+                    cache_key,
+                    result,
+                )
+            except FailedToWriteCacheError as e:
+                logger.warning(f"Failed to write cache for {cache_key}: {str(e)}")
             return result
 
         return wrapper

port_ocean/utils/ipc.py

@@ -0,0 +1,30 @@
+import pickle
+import os
+from typing import Any
+
+
+class FileIPC:
+    def __init__(self, process_id: str, name: str, default_return: Any = None):
+        self.process_id = process_id
+        self.name = name
+        self.dir_path = f"/tmp/p_{self.process_id}"
+        self.file_path = f"{self.dir_path}/{self.name}.pkl"
+        self.default_return = default_return
+        os.makedirs(self.dir_path, exist_ok=True)
+
+    def __del__(self) -> None:
+        self.delete()
+
+    def save(self, object: Any) -> None:
+        with open(self.file_path, "wb") as f:
+            pickle.dump(object, f)
+
+    def load(self) -> Any:
+        if not os.path.exists(self.file_path):
+            return self.default_return
+        with open(self.file_path, "rb") as f:
+            return pickle.load(f)
+
+    def delete(self) -> None:
+        if os.path.exists(self.file_path):
+            os.remove(self.file_path)

{port_ocean-0.22.11.dist-info → port_ocean-0.23.0.dist-info}/METADATA

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

@@ -3,11 +3,18 @@ integrations/_infra/Dockerfile.alpine,sha256=7E4Sb-8supsCcseerHwTkuzjHZoYcaHIyxi
 integrations/_infra/Dockerfile.base.builder,sha256=Ogp_fodUE-lD-HgcfcFJd7pr520LPoEU9GCNk6HQBxk,619
 integrations/_infra/Dockerfile.base.runner,sha256=T7Tis9EjmcOl2jUXPMSENbRXMqwoHnnFPhgRmfEMO5Y,357
 integrations/_infra/Dockerfile.dockerignore,sha256=CM1Fxt3I2AvSvObuUZRmy5BNLSGC7ylnbpWzFgD4cso,1163
+integrations/_infra/Dockerfile.local,sha256=Aqj3y4U6XFS78i5Zz3IfyZkvVmAdB7eEAe6khQaxRxI,876
 integrations/_infra/Makefile,sha256=YgLKvuF_Dw4IA7X98Nus6zIW_3cJ60M1QFGs3imj5c4,2430
+integrations/_infra/entry_local.sh,sha256=cH2Gd82qDnLKXvjoK1MNay9vdIZzTTF_hrhmvZuYZbg,648
 integrations/_infra/grpcio.sh,sha256=m924poYznoRZ6Tt7Ct8Cs5AV_cmmOx598yIZ3z4DvZE,616
 integrations/_infra/init.sh,sha256=nN8lTrOhB286UfFvD6sJ9YJ-9asT9zVSddQB-RAb7Z4,99
-port_ocean/__init__.py,sha256=J3Mqp7d-CkEe9eMigGG8gSEiVKICY2bf7csNEwVOXk0,294
+port_ocean/__init__.py,sha256=uMpjg5d_cXgnyCxA_LmICR8zqBmC6Fe9Ivu9hcvJ7EY,313
 port_ocean/bootstrap.py,sha256=CN1M5pVecZ7z_Vfu86Dk2HjFMiuiwt6E_SSOLFCYRMk,1321
+port_ocean/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+port_ocean/cache/base.py,sha256=XfsIfbE5y22pqr18sJMCCT4kS6h6BztHNpiH2aoubGM,661
+port_ocean/cache/disk.py,sha256=f1FHP74qWwVxMs4UdOzyoTWW0mPVTwfka8rITLi3ISg,1903
+port_ocean/cache/errors.py,sha256=KZ7c3L9k1e0Btw-BBERAxjONKkmQoH7EllTvFEiqQEA,145
+port_ocean/cache/memory.py,sha256=w4Jhvpa56j1vQ1XQ-XFe8KQPVkVzLsF8RmgwZm4XUCA,1246
 port_ocean/cli/__init__.py,sha256=ZjTGS305llhbjC2BH2KkVj34gCASBGwqc5HZEO_0T_Q,328
 port_ocean/cli/cli.py,sha256=RvWTELEn5YFw9aM0vaNqm5YqZZrL50ILaBs27ptiGl0,57
 port_ocean/cli/commands/__init__.py,sha256=Y9Q6jeYw_ZAZ-mdfE_5DZTdS2KHhieQZoUTggk_AkwM,369
@@ -62,7 +69,7 @@ port_ocean/clients/port/utils.py,sha256=osFyAjw7Y5Qf2uVSqC7_RTCQfijiL1zS74JJM0go
 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=pqDn733zNJYxUH-y2oTofHz8_WKekw-4QwhovAzO1nw,6207
+port_ocean/config/settings.py,sha256=kVXF5_Jr93qW4xDlYXbfehDlQjpv4REjiSAQWePKfYs,6438
 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
@@ -113,9 +120,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=4ikStO_BurcB5Hy1uYcWMO-exYJbOnu6by9eYmMJbJU,29490
-port_ocean/core/integrations/mixins/utils.py,sha256=oN4Okz6xlaefpid1_Pud8HPSw9BwwjRohyNsknq-Myg,2309
-port_ocean/core/models.py,sha256=YpJ2XOB3Zt9_M-rcMrMjugFNzBDg2hCUKgqvEt7now0,2348
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=TCxWRyHu5p7Pn1qnl-crqFrf_CoOLEGo7wGs1XRS3ys,32284
+port_ocean/core/integrations/mixins/utils.py,sha256=_Pax41H3U75HZRPkrFbcSYdT4NDGb1LtdF_anuIcj1o,2347
+port_ocean/core/models.py,sha256=MKfq69zGbFRzo0I2HRDUvSbz_pjrtcFVsD5B4Qwa3fw,2538
 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
@@ -131,7 +138,7 @@ port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnq
 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=F7R5JGmyGPsvqBY7wlDfOc15GX28-Kslbw99Y0aETv0,12785
+port_ocean/helpers/metric/metric.py,sha256=iktHKXQNzkLYHgCLWA5wxRDvAMJrJIMoGQYFXV83mH0,12973
 port_ocean/helpers/metric/utils.py,sha256=Wnr-6HwVwBtYJ3so44OkhDRs8udLMSB1oduzl2-zRHo,781
 port_ocean/helpers/retry.py,sha256=gmS4YxM6N4fboFp7GSgtOzyBJemxs46bnrz4L4rDS6Y,16136
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -139,23 +146,26 @@ port_ocean/log/handlers.py,sha256=ncVjgqrZRh6BhyRrA6DQG86Wsbxph1yWYuEC0cWfe-Q,36
 port_ocean/log/logger_setup.py,sha256=0K3zVG0YYrYOWEV8-rCGks1o-bMRxgHXlqawu9w_tSw,2656
 port_ocean/log/sensetive.py,sha256=lVKiZH6b7TkrZAMmhEJRhcl67HNM94e56x12DwFgCQk,2920
 port_ocean/middlewares.py,sha256=9wYCdyzRZGK1vjEJ28FY_DkfwDNENmXp504UKPf5NaQ,2727
-port_ocean/ocean.py,sha256=8yUw9pDBGkqBHza_PKtINz_7G69Ia6o1m8H-SvlKOOk,7462
+port_ocean/ocean.py,sha256=h0d-lOf7FQdrRylEglD1MqNzHk-OdvwAorFWyiT6UBo,8825
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/run.py,sha256=COoRSmLG4hbsjIW5DzhV0NYVegI9xHd1POv6sg4U1No,2217
+port_ocean/run.py,sha256=CmKz14bxfdOooNbQ5QqH1MwX-XLYVG4NgT4KbrzFaqI,2216
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
 port_ocean/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+port_ocean/tests/cache/__init__.py,sha256=mFSl2_of1u8WxZIypvvHkobHsukM3_RjUfCMZQtzZeI,33
+port_ocean/tests/cache/test_disk_cache.py,sha256=5-GXpUepomW4yCWkm43LwzNKlMmH6BOa5cYaXccXAKQ,2702
+port_ocean/tests/cache/test_memory_cache.py,sha256=xlwIOBU0RVLYYJU83l_aoZDzZ6QIDwz-fcKfRkR6dFk,1653
 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_organization_mixin.py,sha256=zzKYz3h8dl4Z5A2QG_924m0y9U6XTth1XYOfwNrd_24,914
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
-port_ocean/tests/core/conftest.py,sha256=BHfi7egDVNRpg61lHZlWj81_ohUG7DEVMdFe9yX-vkc,5517
+port_ocean/tests/core/conftest.py,sha256=tTOxB8HlCmXgSsXhtPI6xYgdpbpemxfBhA_gBDBuACQ,6115
 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/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=ZjAWXpheHa61M9nIj4FUGKt9xMeI4Z1AvE6Nko-uru8,43482
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=QHFigCpvYHf6sVirLBI23pMFyZCn4TcWaaFbHtUjoFA,42441
 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
@@ -177,19 +187,20 @@ port_ocean/tests/test_metric.py,sha256=gDdeJcqJDQ_o3VrYrW23iZyw2NuUsyATdrygSXhcD
 port_ocean/tests/test_ocean.py,sha256=bsXKGTVEjwLSbR7-qSmI4GZ-EzDo0eBE3TNSMsWzYxM,1502
 port_ocean/tests/test_smoke.py,sha256=uix2uIg_yOm8BHDgHw2hTFPy1fiIyxBGW3ENU_KoFlo,2557
 port_ocean/tests/utils/test_async_iterators.py,sha256=3PLk1emEXekb8LcC5GgVh3OicaX15i5WyaJT_eFnu_4,1336
-port_ocean/tests/utils/test_cache.py,sha256=GzoS8xGCBDbBcPwSDbdimsMMkRvJATrBC7UmFhdW3fw,4906
+port_ocean/tests/utils/test_cache.py,sha256=MIYzHt1DeVJ_2KNpVfnUaivNlmdzXDBC5ZeixJPPKL8,8591
 port_ocean/utils/__init__.py,sha256=KMGnCPXZJbNwtgxtyMycapkDz8tpSyw23MSYT3iVeHs,91
 port_ocean/utils/async_http.py,sha256=aDsw3gQIMwt6qLegbZtkHqD8em48tKvbITnblsrTY3g,1260
 port_ocean/utils/async_iterators.py,sha256=CPXskYWkhkZtAG-ducEwM8537t3z5usPEqXR9vcivzw,3715
-port_ocean/utils/cache.py,sha256=RgfN4SjjHrEkbqUChyboeD1mrXomolUUjsJtvbkmr3U,3353
+port_ocean/utils/cache.py,sha256=tRwPomG2VIxx8ZNi4QYH6Yc47d9yYV1A7Hx-L_fX4Dg,4494
+port_ocean/utils/ipc.py,sha256=BMVUxdftf0i7Z2Xp8KMFlttUjZhTE7VUCpY4SBBnoVY,896
 port_ocean/utils/misc.py,sha256=0q2cJ5psqxn_5u_56pT7vOVQ3shDM02iC1lzyWQ_zl0,2098
 port_ocean/utils/queue_utils.py,sha256=KWWl8YVnG-glcfIHhM6nefY-2sou_C6DVP1VynQwzB4,2762
 port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,3229
 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.22.11.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.22.11.dist-info/METADATA,sha256=Fo942o0gljfDJTPxcKfgK3fpbBVSQluymPor_ztGo2Q,6765
-port_ocean-0.22.11.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.22.11.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.22.11.dist-info/RECORD,,
+port_ocean-0.23.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.23.0.dist-info/METADATA,sha256=RAOhyPDxeKshLjPZ4hTM8uKjumyU2GZgpJDcjjNC-jY,6764
+port_ocean-0.23.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.23.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.23.0.dist-info/RECORD,,