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

integrations/_infra/Dockerfile.Deb

@@ -5,11 +5,15 @@ 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
+    PIP_ROOT_USER_ACTION=ignore \
+    PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
+
+RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 
 WORKDIR /app
 

integrations/_infra/Dockerfile.local

@@ -25,6 +25,11 @@ RUN apt-get update \
     && apt-get clean
 
 ARG BUILD_CONTEXT
+ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
+
+ENV PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
+
+RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 
 WORKDIR /app
 

integrations/_infra/entry_local.sh

@@ -1,6 +1,4 @@
 #!/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

port_ocean/clients/port/mixins/integrations.py

@@ -214,8 +214,9 @@ class IntegrationClientMixin:
         logger.debug("starting POST metrics request", metrics=metrics)
         metrics_attributes = await self.get_metrics_attributes()
         headers = await self.auth.headers()
+        url = metrics_attributes["ingestUrl"] + "/syncMetrics"
         response = await self.client.post(
-            metrics_attributes["ingestUrl"],
+            url,
             headers=headers,
             json={
                 "syncKindsMetrics": metrics,
@@ -229,7 +230,7 @@ class IntegrationClientMixin:
         metrics_attributes = await self.get_metrics_attributes()
         url = (
             metrics_attributes["ingestUrl"]
-            + f"/resync/{kind_metrics['eventId']}/kind/{kind_metrics['kindIdentifier']}"
+            + f"/syncMetrics/resync/{kind_metrics['eventId']}/kind/{kind_metrics['kindIdentifier']}"
         )
         headers = await self.auth.headers()
         response = await self.client.put(

port_ocean/context/metric_resource.py

@@ -0,0 +1,63 @@
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import AsyncIterator, TYPE_CHECKING
+
+from loguru import logger
+from werkzeug.local import LocalStack, LocalProxy
+
+from port_ocean.exceptions.context import (
+    ResourceContextNotFoundError,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class MetricResourceContext:
+    """
+    The metric resource context is a context manager that allows you to access the current metric resource if there is one.
+    This is useful for getting the metric resource kind
+    """
+
+    metric_resource_kind: str
+    index: int
+
+    @property
+    def kind(self) -> str:
+        return self.metric_resource_kind
+
+
+_resource_context_stack: LocalStack[MetricResourceContext] = LocalStack()
+
+
+def _get_metric_resource_context() -> MetricResourceContext:
+    """
+    Get the context from the current thread.
+    """
+    top_resource_context = _resource_context_stack.top
+    if top_resource_context is None:
+        raise ResourceContextNotFoundError(
+            "You must be inside an metric resource context in order to use it"
+        )
+
+    return top_resource_context
+
+
+metric_resource: MetricResourceContext = LocalProxy(lambda: _get_metric_resource_context())  # type: ignore
+
+
+@asynccontextmanager
+async def metric_resource_context(
+    metric_resource_kind: str, index: int = 0
+) -> AsyncIterator[MetricResourceContext]:
+    _resource_context_stack.push(
+        MetricResourceContext(metric_resource_kind=metric_resource_kind, index=index)
+    )
+
+    with logger.contextualize(
+        metric_resource_kind=metric_resource.metric_resource_kind
+    ):
+        yield metric_resource
+
+    _resource_context_stack.pop()

port_ocean/core/handlers/resync_state_updater/updater.py

@@ -94,6 +94,6 @@ class ResyncStateUpdater:
         await ocean.metrics.send_metrics_to_webhook(
             kind=ocean.metrics.current_resource_kind()
         )
-        # await ocean.metrics.report_sync_metrics(
-        #     kinds=[ocean.metrics.current_resource_kind()]
-        # ) # TODO: uncomment this when end points are ready
+        await ocean.metrics.report_sync_metrics(
+            kinds=[ocean.metrics.current_resource_kind()]
+        )

port_ocean/core/integrations/mixins/sync_raw.py

@@ -9,6 +9,7 @@ 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.metric_resource import metric_resource_context
 from port_ocean.context.ocean import ocean
 from port_ocean.context.resource import resource_context
 from port_ocean.context import resource
@@ -16,6 +17,7 @@ from port_ocean.core.handlers.port_app_config.models import ResourceConfig
 from port_ocean.core.integrations.mixins import HandlerMixin, EventsMixin
 from port_ocean.core.integrations.mixins.utils import (
     ProcessWrapper,
+    clear_http_client_context,
     is_resource_supported,
     unsupported_kind_response,
     resync_generator_wrapper,
@@ -32,8 +34,8 @@ from port_ocean.core.ocean_types import (
 )
 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.helpers.metric.metric import SyncState, MetricType, MetricPhase
-from port_ocean.helpers.metric.utils import TimeMetric
+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
 
 SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
@@ -248,9 +250,16 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                             labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.SKIPPED],
                             value=len(objects_diff[0].entity_selector_diff.passed) - len(changed_entities)
                         )
-                    await self.entities_state_applier.upsert(
+                    upserted_entities = await self.entities_state_applier.upsert(
                         changed_entities, user_agent_type
                     )
+
+                    ocean.metrics.set_metric(
+                        name=MetricType.OBJECT_COUNT_NAME,
+                        labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.LOADED],
+                        value=len(upserted_entities)
+                    )
+
                 else:
                     logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
                     ocean.metrics.inc_metric(
@@ -264,6 +273,11 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 modified_objects = await self.entities_state_applier.upsert(
                     objects_diff[0].entity_selector_diff.passed, user_agent_type
                     )
+                ocean.metrics.set_metric(
+                        name=MetricType.OBJECT_COUNT_NAME,
+                        labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.LOADED],
+                        value=len(upserted_entities)
+                    )
         else:
            modified_objects = await self.entities_state_applier.upsert(
                     objects_diff[0].entity_selector_diff.passed, user_agent_type
@@ -594,6 +608,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
     ) -> None:
         logger.info(f"process started successfully for {resource.kind} with index {index}")
 
+        clear_http_client_context()
         async def process_resource_task() -> None:
             result = await self._process_resource(
                 resource, index, user_agent_type
@@ -631,16 +646,12 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         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
@@ -648,10 +659,88 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             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
+            await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id, blueprint=resource.port.entity.mappings.blueprint)
 
             return kind_results
 
+    @TimeMetricWithResourceKind(MetricPhase.RESYNC)
+    async def resync_reconciliation(
+        self,
+        creation_results: list[tuple[list[Entity], list[Exception]]],
+        did_fetched_current_state: bool,
+        user_agent_type: UserAgentType,
+        app_config: Any,
+        silent: bool = True,
+    ) -> None:
+        """Handle the reconciliation phase of the resync process.
+
+        This method handles:
+        1. Sorting and upserting failed entities
+        2. Checking if current state was fetched
+        3. Calculating resync diff
+        4. Handling errors
+        5. Deleting entities that are no longer needed
+        6. Executing resync complete hooks
+
+        Args:
+            creation_results (list[tuple[list[Entity], list[Exception]]]): Results from entity creation
+            did_fetched_current_state (bool): Whether the current state was successfully fetched
+            user_agent_type (UserAgentType): The type of user agent
+            app_config (Any): The application configuration
+            silent (bool): Whether to raise exceptions or handle them silently
+
+        """
+        await self.sort_and_upsert_failed_entities(user_agent_type)
+
+        if not did_fetched_current_state:
+            logger.warning(
+                "Due to an error before the resync, the previous state of entities at Port is unknown."
+                " Skipping delete phase due to unknown initial state."
+            )
+            return False
+
+        logger.info("Starting resync diff calculation")
+        generated_entities, errors = zip_and_sum(creation_results) or [
+            [],
+            [],
+        ]
+
+        if errors:
+            message = f"Resync failed with {len(errors)} errors, skipping delete phase due to incomplete state"
+            error_group = ExceptionGroup(
+                message,
+                errors,
+            )
+            if not silent:
+                raise error_group
+
+            logger.error(message, exc_info=error_group)
+            return False
+
+        logger.info(
+            f"Running resync diff calculation, number of entities created during sync: {len(generated_entities)}"
+        )
+        entities_at_port = await ocean.port_client.search_entities(
+            user_agent_type
+        )
+
+        await self.entities_state_applier.delete_diff(
+            {"before": entities_at_port, "after": generated_entities},
+            user_agent_type, app_config.get_entity_deletion_threshold()
+        )
+
+        logger.info("Resync finished successfully")
+
+        # Execute resync_complete hooks
+        if "resync_complete" in self.event_strategy:
+            logger.info("Executing resync_complete hooks")
+
+            for resync_complete_fn in self.event_strategy["resync_complete"]:
+                await resync_complete_fn()
+
+            logger.info("Finished executing resync_complete hooks")
+
+
     @TimeMetric(MetricPhase.RESYNC)
     async def sync_raw_all(
         self,
@@ -687,8 +776,9 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
 
             kinds = [f"{resource.kind}-{index}" for index, resource in enumerate(app_config.resources)]
+            blueprints = [resource.port.entity.mappings.blueprint for resource in app_config.resources]
             ocean.metrics.initialize_metrics(kinds)
-            # await ocean.metrics.report_sync_metrics(kinds=kinds) # TODO: uncomment this when end points are ready
+            await ocean.metrics.report_sync_metrics(kinds=kinds, blueprints=blueprints)
 
             # Clear cache
             await ocean.app.cache_provider.clear()
@@ -714,64 +804,21 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             multiprocessing.set_start_method('fork', True)
             try:
                 for index,resource in enumerate(app_config.resources):
-
                     logger.info(f"Starting processing resource {resource.kind} with index {index}")
-
                     creation_results.append(await self.process_resource(resource,index,user_agent_type))
-
-                await self.sort_and_upsert_failed_entities(user_agent_type)
-
             except asyncio.CancelledError as e:
                 logger.warning("Resync aborted successfully, skipping delete phase. This leads to an incomplete state")
                 raise
             else:
-                if not did_fetched_current_state:
-                    logger.warning(
-                        "Due to an error before the resync, the previous state of entities at Port is unknown."
-                        " Skipping delete phase due to unknown initial state."
-                    )
-                    return
-
-                logger.info("Starting resync diff calculation")
-                generated_entities, errors = zip_and_sum(creation_results) or [
-                    [],
-                    [],
-                ]
-
-                if errors:
-                    message = f"Resync failed with {len(errors)} errors, skipping delete phase due to incomplete state"
-                    error_group = ExceptionGroup(
-                        message,
-                        errors,
-                    )
-                    if not silent:
-                        raise error_group
-
-                    logger.error(message, exc_info=error_group)
-                    return False
-                else:
-                    logger.info(
-                        f"Running resync diff calculation, number of entities created during sync: {len(generated_entities)}"
-                    )
-                    entities_at_port = await ocean.port_client.search_entities(
-                        user_agent_type
-                    )
-                    await self.entities_state_applier.delete_diff(
-                        {"before": entities_at_port, "after": generated_entities},
-                        user_agent_type, app_config.get_entity_deletion_threshold()
-                    )
-
-                    logger.info("Resync finished successfully")
-
-                    # Execute resync_complete hooks
-                    if "resync_complete" in self.event_strategy:
-                        logger.info("Executing resync_complete hooks")
-
-                        for resync_complete_fn in self.event_strategy["resync_complete"]:
-                            await resync_complete_fn()
-
-                        logger.info("Finished executing resync_complete hooks")
-
-                    return True
+                await self.resync_reconciliation(
+                    creation_results,
+                    did_fetched_current_state,
+                    user_agent_type,
+                    app_config,
+                    silent
+                )
+                await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RECONCILIATION])
             finally:
                 await ocean.app.cache_provider.clear()
+                if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+                    ocean.metrics.cleanup_prometheus_metrics()

port_ocean/core/integrations/mixins/utils.py

@@ -19,6 +19,10 @@ from port_ocean.exceptions.core import (
     KindNotImplementedException,
 )
 
+from port_ocean.utils.async_http import _http_client
+from port_ocean.clients.port.utils import _http_client as _port_http_client
+
+from port_ocean.context.ocean import ocean
 
 @contextmanager
 def resync_error_handling() -> Generator[None, None, None]:
@@ -76,6 +80,7 @@ def unsupported_kind_response(
     logger.error(f"Kind {kind} is not supported in this integration")
     return [], [KindNotImplementedException(kind, available_resync_kinds)]
 
+
 class ProcessWrapper(multiprocessing.Process):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -87,4 +92,18 @@ class ProcessWrapper(multiprocessing.Process):
             logger.error(f"Process {self.pid} failed with exit code {self.exitcode}")
         else:
             logger.info(f"Process {self.pid} finished with exit code {self.exitcode}")
+        ocean.metrics.cleanup_prometheus_metrics(self.pid)
         return super().join()
+
+def clear_http_client_context() -> None:
+    try:
+        while _http_client.top is not None:
+            _http_client.pop()
+    except (RuntimeError, AttributeError):
+        pass
+
+    try:
+        while _port_http_client.top is not None:
+            _port_http_client.pop()
+    except (RuntimeError, AttributeError):
+        pass

port_ocean/helpers/metric/metric.py

@@ -1,11 +1,12 @@
+import os
 from typing import Any, TYPE_CHECKING, Optional, Dict, List, Tuple
 from fastapi import APIRouter
 from port_ocean.exceptions.context import ResourceContextNotFoundError
 import prometheus_client
 from httpx import AsyncClient
-
+from fastapi.responses import PlainTextResponse
 from loguru import logger
-from port_ocean.context import resource
+from port_ocean.context import metric_resource, resource
 from prometheus_client import Gauge
 import prometheus_client.openmetrics
 import prometheus_client.openmetrics.exposition
@@ -56,6 +57,11 @@ class SyncState:
     FAILED = "failed"
 
 
+class MetricResourceKind:
+    RECONCILIATION = "__reconciliation__"
+    RESYNC = "__resync__"
+
+
 # Registry for core and custom metrics
 _metrics_registry: Dict[str, Tuple[str, str, List[str]]] = {
     MetricType.DURATION_NAME: (
@@ -193,7 +199,21 @@ class Metrics:
         """
         self.get_metric(name, labels).set(value)
 
+    @staticmethod
+    def cleanup_prometheus_metrics(pid: int | None = None) -> None:
+        try:
+            prometheus_multiproc_dir = os.environ.get("PROMETHEUS_MULTIPROC_DIR")
+            for file in os.listdir(prometheus_multiproc_dir):
+                if pid:
+                    if file.endswith(".db") and file[0:-3].split("_")[-1] == str(pid):
+                        os.remove(f"{prometheus_multiproc_dir}/{file}")
+                else:
+                    os.remove(f"{prometheus_multiproc_dir}/{file}")
+        except Exception as e:
+            logger.error(f"Failed to cleanup prometheus metrics: {e}")
+
     def initialize_metrics(self, kind_blockes: list[str]) -> None:
+        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)
@@ -237,11 +257,9 @@ class Metrics:
             )
 
     def create_mertic_router(self) -> APIRouter:
-        if not self.enabled:
-            return APIRouter()
         router = APIRouter()
 
-        @router.get("/")
+        @router.get("/", response_class=PlainTextResponse)
         async def prom_metrics() -> str:
             return self.generate_latest()
 
@@ -250,6 +268,12 @@ class Metrics:
     def current_resource_kind(self) -> str:
         try:
             return f"{resource.resource.kind}-{resource.resource.index}"
+        except ResourceContextNotFoundError:
+            return self.current_metric_resource_kind()
+
+    def current_metric_resource_kind(self) -> str:
+        try:
+            return metric_resource.metric_resource.metric_resource_kind
         except ResourceContextNotFoundError:
             return "__runtime__"
 
@@ -259,15 +283,21 @@ class Metrics:
         ).decode()
 
     async def report_sync_metrics(
-        self, metric_name: Optional[str] = None, kinds: Optional[list[str]] = None
+        self,
+        metric_name: Optional[str] = None,
+        kinds: Optional[list[str]] = None,
+        blueprints: Optional[list[Optional[str]]] = None,
     ) -> None:
         if kinds is None:
             return None
 
         metrics = []
 
-        for kind in kinds:
-            metric = self.generate_metrics(metric_name, kind)
+        if blueprints is None:
+            blueprints = [None] * len(kinds)
+
+        for kind, blueprint in zip(kinds, blueprints):
+            metric = self.generate_metrics(metric_name, kind, blueprint)
             metrics.extend(metric)
 
         try:
@@ -276,9 +306,12 @@ class Metrics:
             logger.error(f"Error posting metrics: {e}", metrics=metrics)
 
     async def report_kind_sync_metrics(
-        self, metric_name: Optional[str] = None, kind: Optional[str] = None
+        self,
+        metric_name: Optional[str] = None,
+        kind: Optional[str] = None,
+        blueprint: Optional[str] = None,
     ) -> None:
-        metrics = self.generate_metrics(metric_name, kind)
+        metrics = self.generate_metrics(metric_name, kind, blueprint)
         if not metrics:
             return None
 
@@ -289,7 +322,10 @@ class Metrics:
             logger.error(f"Error putting metrics: {e}", metrics=metrics)
 
     def generate_metrics(
-        self, metric_name: Optional[str] = None, kind: Optional[str] = None
+        self,
+        metric_name: Optional[str] = None,
+        kind: Optional[str] = None,
+        blueprint: Optional[str] = None,
     ) -> list[dict[str, Any]]:
         try:
             latest_raw = self.generate_latest()
@@ -348,9 +384,10 @@ class Metrics:
                         if "-" in kind_key
                         else kind_key
                     ),
-                    "kindIndex": 0 if kind_key == "__runtime__" else int(kind_key[-1]),
+                    "kindIndex": int(kind_key[-1]) if kind_key[-1].isdigit() else 0,
                     "eventId": self.event_id,
                     "syncState": self.sync_state,
+                    "blueprint": blueprint if blueprint else "",
                     "metrics": metrics,
                 }
                 events.append(event)

port_ocean/helpers/metric/utils.py

@@ -2,8 +2,9 @@ from functools import wraps
 import time
 from typing import Any, Callable
 
+from port_ocean.context.metric_resource import metric_resource_context
 from port_ocean.context.ocean import ocean
-from port_ocean.helpers.metric.metric import MetricType
+from port_ocean.helpers.metric.metric import MetricResourceKind, MetricType
 
 
 def TimeMetric(phase: str) -> Any:
@@ -26,3 +27,26 @@ def TimeMetric(phase: str) -> Any:
         return wrapper
 
     return decorator
+
+
+def TimeMetricWithResourceKind(phase: str) -> Any:
+    def decorator(func: Callable[..., Any]) -> Any:
+
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: dict[Any, Any]) -> Any:
+            async with metric_resource_context(MetricResourceKind.RECONCILIATION):
+                start = time.monotonic()
+                res = await func(*args, **kwargs)
+                end = time.monotonic()
+                duration = end - start
+                ocean.metrics.inc_metric(
+                    name=MetricType.DURATION_NAME,
+                    labels=[ocean.metrics.current_resource_kind(), phase],
+                    value=duration,
+                )
+
+                return res
+
+        return wrapper
+
+    return decorator

port_ocean/ocean.py

@@ -96,7 +96,6 @@ class Ocean:
         self.resync_state_updater = ResyncStateUpdater(
             self.port_client, self.config.scheduled_resync_interval
         )
-
         self.app_initialized = False
 
     def _get_process_execution_mode(self) -> ProcessExecutionMode:

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

@@ -154,7 +154,7 @@ async def test_sync_raw_mixin_self_dependency(
 
                 # Add assertions for actual metrics
                 metrics = mock_ocean.metrics.generate_metrics()
-                assert len(metrics) == 2
+                assert len(metrics) == 3
 
                 # Verify object counts
                 for metric in metrics:
@@ -187,7 +187,7 @@ async def test_sync_raw_mixin_self_dependency(
                             metric["metrics"]["phase"]["load"]["object_count_type"][
                                 "loaded"
                             ]["object_count"]
-                            == 2
+                            == 1
                         )
 
                         # Verify success
@@ -196,6 +196,14 @@ async def test_sync_raw_mixin_self_dependency(
                         # Verify sync state
                         assert metric["syncState"] == "completed"
 
+                    if metric["kind"] == "reconciliation":
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 1
+                        )
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_circular_dependency(
@@ -282,7 +290,7 @@ async def test_sync_raw_mixin_circular_dependency(
 
                 # Add assertions for actual metrics
                 metrics = mock_ocean.metrics.generate_metrics()
-                assert len(metrics) == 2
+                assert len(metrics) == 3
 
                 # Verify object counts
                 for metric in metrics:
@@ -315,7 +323,7 @@ async def test_sync_raw_mixin_circular_dependency(
                             metric["metrics"]["phase"]["load"]["object_count_type"][
                                 "loaded"
                             ]["object_count"]
-                            == 2
+                            == 0
                         )
 
                         # Verify success
@@ -324,6 +332,14 @@ async def test_sync_raw_mixin_circular_dependency(
                         # Verify sync state
                         assert metric["syncState"] == "completed"
 
+                    if metric["kind"] == "reconciliation":
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 2
+                        )
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_dependency(
@@ -422,7 +438,7 @@ async def test_sync_raw_mixin_dependency(
 
                 # Add assertions for actual metrics
                 metrics = mock_ocean.metrics.generate_metrics()
-                assert len(metrics) == 2
+                assert len(metrics) == 3
 
                 # Verify object counts
                 for metric in metrics:
@@ -458,6 +474,14 @@ async def test_sync_raw_mixin_dependency(
                         # Verify sync state
                         assert metric["syncState"] == "completed"
 
+                    if metric["kind"] == "reconciliation":
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 5
+                        )
+
 
 @pytest.mark.asyncio
 async def test_register_raw(

port_ocean/utils/ipc.py

@@ -7,7 +7,7 @@ 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.dir_path = f"/tmp/ocean/processes/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)

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

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

{port_ocean-0.23.2.dist-info → port_ocean-0.23.4.dist-info}/RECORD

@@ -1,11 +1,11 @@
-integrations/_infra/Dockerfile.Deb,sha256=ruQRZwWN5qrJCecgA-rZklX1zXO8OAS78SjAqMv6dLg,1519
+integrations/_infra/Dockerfile.Deb,sha256=JMyxgvJxLeo3Vcys-w6m_F6fxfu6JyAcjAMPuXsNQBM,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
 integrations/_infra/Dockerfile.dockerignore,sha256=CM1Fxt3I2AvSvObuUZRmy5BNLSGC7ylnbpWzFgD4cso,1163
-integrations/_infra/Dockerfile.local,sha256=Aqj3y4U6XFS78i5Zz3IfyZkvVmAdB7eEAe6khQaxRxI,876
+integrations/_infra/Dockerfile.local,sha256=4M5wyksRcGQ0WSXfDcJsHshE8uUSQw5yf6O3JK_DyK4,1035
 integrations/_infra/Makefile,sha256=YgLKvuF_Dw4IA7X98Nus6zIW_3cJ60M1QFGs3imj5c4,2430
-integrations/_infra/entry_local.sh,sha256=cH2Gd82qDnLKXvjoK1MNay9vdIZzTTF_hrhmvZuYZbg,648
+integrations/_infra/entry_local.sh,sha256=GIuAXACcYv4DDxH6ubDidNJboqmAJYW4OanUK_VW4nQ,547
 integrations/_infra/grpcio.sh,sha256=m924poYznoRZ6Tt7Ct8Cs5AV_cmmOx598yIZ3z4DvZE,616
 integrations/_infra/init.sh,sha256=nN8lTrOhB286UfFvD6sJ9YJ-9asT9zVSddQB-RAb7Z4,99
 port_ocean/__init__.py,sha256=uMpjg5d_cXgnyCxA_LmICR8zqBmC6Fe9Ivu9hcvJ7EY,313
@@ -60,7 +60,7 @@ port_ocean/clients/port/client.py,sha256=dv0mxIOde6J-wFi1FXXZkoNPVHrZzY7RSMhNkDD
 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/integrations.py,sha256=QuPZ4MC8FtJ-3FKbm0CqJ5TOxtSyaQLR_rsJ-p7-y_Q,11115
+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
 port_ocean/clients/port/retry_transport.py,sha256=PtIZOAZ6V-ncpVysRUsPOgt8Sf01QLnTKB5YeKBxkJk,1861
@@ -74,6 +74,7 @@ port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/context/event.py,sha256=z7DBNOPOL9P3s-SR8jpgwoyaQ6IL9vZxLaAxIjv1Faw,6493
+port_ocean/context/metric_resource.py,sha256=_EbLRjv3r1y6E3B9mU10wuGg_oepD8zo3VueaJMeH6A,1689
 port_ocean/context/ocean.py,sha256=xWD30AbStQK44QFW9ad5pO4i5dQG7uouvjuHScKnJOM,7884
 port_ocean/context/resource.py,sha256=WQlPzplxWic0hvvMxWKu8xPfQQC0VjrsJVeA6yZytw0,1712
 port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -108,7 +109,7 @@ port_ocean/core/handlers/queue/__init__.py,sha256=1fICM0ZLATmmj6f7cdq_eV2kmw0_jy
 port_ocean/core/handlers/queue/abstract_queue.py,sha256=q_gpaWFFZHxM3XovEbgsDn8jEOLM45iAZWVC81Paxto,620
 port_ocean/core/handlers/queue/local_queue.py,sha256=EzqsGIX43xbVAcePwTcCg5QDrXATQpy-VzWxxN_OyAM,574
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
-port_ocean/core/handlers/resync_state_updater/updater.py,sha256=KZ55dubVYmFHxUOzdUFBPGLQhQSVBiRAoyk3R-NKKRU,3819
+port_ocean/core/handlers/resync_state_updater/updater.py,sha256=TRYq6QnTtPlJg6MvgZPtQdZPvkAhkvpcmWjtkxCnkg4,3764
 port_ocean/core/handlers/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=5KwZkdkDd5HdVkXPzKiqabodZKl-hOtMypkTKd8Hq3M,3891
 port_ocean/core/handlers/webhook/processor_manager.py,sha256=ipyAXoFtF84EGczyzRcZCzQG4Ippjo4eMsnVxMVz12A,12072
@@ -120,8 +121,8 @@ 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=XIVx_Y9TM8TCMzuoNowYGNtQG98n2pLTCFFHWbkIbTo,32176
-port_ocean/core/integrations/mixins/utils.py,sha256=0rzzFnxrFNaVLHXShfDda5zjO8WwEUBW9oPWxnDsaXQ,2878
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=wZrn0Bz05HmVKDgAJ5LPvP54nSUDpE8uHvjHAYqXVD4,33987
+port_ocean/core/integrations/mixins/utils.py,sha256=g1XbC12dswefQ-NpcLSCqFtd_WRp2bTL98jyZ5rRbGk,3444
 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
@@ -138,15 +139,15 @@ 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=iktHKXQNzkLYHgCLWA5wxRDvAMJrJIMoGQYFXV83mH0,12973
-port_ocean/helpers/metric/utils.py,sha256=Wnr-6HwVwBtYJ3so44OkhDRs8udLMSB1oduzl2-zRHo,781
+port_ocean/helpers/metric/metric.py,sha256=mlXH4T_ehShZ0XjGkng3h4MDv7Myw0upwTlpAoC84tA,14395
+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
 port_ocean/log/handlers.py,sha256=ncVjgqrZRh6BhyRrA6DQG86Wsbxph1yWYuEC0cWfe-Q,3631
 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=h0d-lOf7FQdrRylEglD1MqNzHk-OdvwAorFWyiT6UBo,8825
+port_ocean/ocean.py,sha256=83zgTEI5o2wfl8mq-iIC9DzPOZbWyCqNIy1BEjv9TOk,8824
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=CmKz14bxfdOooNbQ5QqH1MwX-XLYVG4NgT4KbrzFaqI,2216
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -165,7 +166,7 @@ port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcG
 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=QHFigCpvYHf6sVirLBI23pMFyZCn4TcWaaFbHtUjoFA,42441
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=iK-lfu6vk-DBScYm-nLvRzbj0ImbKUN4LfNLXOb8Z3Q,43413
 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
@@ -192,15 +193,15 @@ port_ocean/utils/__init__.py,sha256=KMGnCPXZJbNwtgxtyMycapkDz8tpSyw23MSYT3iVeHs,
 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=tRwPomG2VIxx8ZNi4QYH6Yc47d9yYV1A7Hx-L_fX4Dg,4494
-port_ocean/utils/ipc.py,sha256=BMVUxdftf0i7Z2Xp8KMFlttUjZhTE7VUCpY4SBBnoVY,896
+port_ocean/utils/ipc.py,sha256=eTjTTvsKl6IXYeOkIjP5iyrw-8gLQ9rf15WeyxCqXog,912
 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.23.2.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.23.2.dist-info/METADATA,sha256=VnbW8FFOYaCKz8w6PUz0nxZgkpzED3Ny8ui9qB5uXBY,6764
-port_ocean-0.23.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.23.2.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.23.2.dist-info/RECORD,,
+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,,