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

port_ocean/clients/port/mixins/integrations.py

@@ -25,6 +25,10 @@ class LogAttributes(TypedDict):
     ingestUrl: str
 
 
+class MetricsAttributes(TypedDict):
+    ingestUrl: str
+
+
 class IntegrationClientMixin:
     def __init__(
         self,
@@ -38,6 +42,7 @@ class IntegrationClientMixin:
         self.auth = auth
         self.client = client
         self._log_attributes: LogAttributes | None = None
+        self._metrics_attributes: MetricsAttributes | None = None
 
     async def is_integration_provision_enabled(
         self, integration_type: str, should_raise: bool = True, should_log: bool = True
@@ -106,6 +111,12 @@ class IntegrationClientMixin:
             self._log_attributes = response["logAttributes"]
         return self._log_attributes
 
+    async def get_metrics_attributes(self) -> LogAttributes:
+        if self._metrics_attributes is None:
+            response = await self.get_current_integration()
+            self._metrics_attributes = response["metricAttributes"]
+        return self._metrics_attributes
+
     async def _poll_integration_until_default_provisioning_is_complete(
         self,
     ) -> Dict[str, Any]:
@@ -197,6 +208,40 @@ class IntegrationClientMixin:
         handle_port_status_code(response)
         return response.json()["integration"]
 
+    async def post_integration_sync_metrics(
+        self, metrics: list[dict[str, Any]]
+    ) -> None:
+        logger.debug("starting POST metrics request", metrics=metrics)
+        metrics_attributes = await self.get_metrics_attributes()
+        headers = await self.auth.headers()
+        response = await self.client.post(
+            metrics_attributes["ingestUrl"],
+            headers=headers,
+            json={
+                "syncKindsMetrics": metrics,
+            },
+        )
+        handle_port_status_code(response, should_log=False)
+        logger.debug("Finished POST metrics request")
+
+    async def put_integration_sync_metrics(self, kind_metrics: dict[str, Any]) -> None:
+        logger.debug("starting PUT metrics request", kind_metrics=kind_metrics)
+        metrics_attributes = await self.get_metrics_attributes()
+        url = (
+            metrics_attributes["ingestUrl"]
+            + f"/resync/{kind_metrics['eventId']}/kind/{kind_metrics['kindIdentifier']}"
+        )
+        headers = await self.auth.headers()
+        response = await self.client.put(
+            url,
+            headers=headers,
+            json={
+                "syncKindMetrics": kind_metrics,
+            },
+        )
+        handle_port_status_code(response, should_log=False)
+        logger.debug("Finished PUT metrics request")
+
     async def ingest_integration_logs(self, logs: list[dict[str, Any]]) -> None:
         logger.debug("Ingesting logs")
         log_attributes = await self.get_log_attributes()

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

@@ -104,8 +104,12 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
         ):
             await self._safe_delete(diff.deleted, kept_entities, user_agent_type)
             ocean.metrics.inc_metric(
-                name=MetricType.DELETION_COUNT_NAME,
-                labels=[ocean.metrics.current_resource_kind(), MetricPhase.DELETE],
+                name=MetricType.OBJECT_COUNT_NAME,
+                labels=[
+                    ocean.metrics.current_resource_kind(),
+                    MetricPhase.DELETE,
+                    MetricPhase.DeletionResult.DELETED,
+                ],
                 value=len(diff.deleted),
             )
         else:

port_ocean/core/handlers/resync_state_updater/updater.py

@@ -90,4 +90,10 @@ class ResyncStateUpdater:
             labels=[ocean.metrics.current_resource_kind(), MetricPhase.RESYNC],
             value=int(status == IntegrationStateStatus.Completed),
         )
-        await ocean.metrics.flush(kind=ocean.metrics.current_resource_kind())
+
+        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

port_ocean/core/integrations/mixins/sync_raw.py

@@ -614,8 +614,10 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 use_cache=False
             )
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
-            ocean.metrics.initialize_metrics([f"{resource.kind}-{index}" for index, resource in enumerate(app_config.resources)])
-            await ocean.metrics.flush()
+
+            kinds = [f"{resource.kind}-{index}" for index, resource in enumerate(app_config.resources)]
+            ocean.metrics.initialize_metrics(kinds)
+            # await ocean.metrics.report_sync_metrics(kinds=kinds) # TODO: uncomment this when end points are ready
 
             # Execute resync_start hooks
             for resync_start_fn in self.event_strategy["resync_start"]:
@@ -643,7 +645,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     async with resource_context(resource,index):
                         resource_kind_id = f"{resource.kind}-{index}"
                         ocean.metrics.sync_state = SyncState.SYNCING
-                        await ocean.metrics.flush(kind=resource_kind_id)
+                        # 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)
@@ -653,9 +655,14 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         kind_results: tuple[list[Entity], list[Exception]] = await task
 
                         creation_results.append(kind_results)
+
                         if ocean.metrics.sync_state != SyncState.FAILED:
                             ocean.metrics.sync_state = SyncState.COMPLETED
-                        await ocean.metrics.flush(kind=resource_kind_id)
+
+                        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 self.sort_and_upsert_failed_entities(user_agent_type)
 

port_ocean/helpers/metric/metric.py

@@ -13,6 +13,7 @@ import prometheus_client.parser
 
 if TYPE_CHECKING:
     from port_ocean.config.settings import MetricsSettings, IntegrationSettings
+    from port_ocean.clients.port.client import PortClient
 
 
 class MetricPhase:
@@ -35,21 +36,22 @@ class MetricPhase:
     class ExtractResult:
         EXTRACTED = "raw_extracted"
 
+    class DeletionResult:
+        DELETED = "deleted"
+
 
 class MetricType:
     # Define metric names as constants
     DURATION_NAME = "duration_seconds"
     OBJECT_COUNT_NAME = "object_count"
-    ERROR_COUNT_NAME = "error_count"
     SUCCESS_NAME = "success"
     RATE_LIMIT_WAIT_NAME = "rate_limit_wait_seconds"
-    DELETION_COUNT_NAME = "deletion_count"
 
 
 class SyncState:
     SYNCING = "syncing"
     COMPLETED = "completed"
-    QUEUED = "queued"
+    PENDING = "pending"
     FAILED = "failed"
 
 
@@ -65,11 +67,6 @@ _metrics_registry: Dict[str, Tuple[str, str, List[str]]] = {
         "object_count description",
         ["kind", "phase", "object_count_type"],
     ),
-    MetricType.ERROR_COUNT_NAME: (
-        MetricType.ERROR_COUNT_NAME,
-        "error_count description",
-        ["kind", "phase"],
-    ),
     MetricType.SUCCESS_NAME: (
         MetricType.SUCCESS_NAME,
         "success description",
@@ -80,11 +77,6 @@ _metrics_registry: Dict[str, Tuple[str, str, List[str]]] = {
         "rate_limit_wait description",
         ["kind", "phase", "endpoint"],
     ),
-    MetricType.DELETION_COUNT_NAME: (
-        MetricType.DELETION_COUNT_NAME,
-        "deletion_count description",
-        ["kind", "phase"],
-    ),
 }
 
 
@@ -115,16 +107,18 @@ class Metrics:
         self,
         metrics_settings: "MetricsSettings",
         integration_configuration: "IntegrationSettings",
+        port_client: "PortClient",
     ) -> None:
         self.metrics_settings = metrics_settings
         self.integration_configuration = integration_configuration
+        self.port_client = port_client
         self.registry = prometheus_client.CollectorRegistry()
         self.metrics: dict[str, Gauge] = {}
         self.load_metrics()
         self._integration_version: Optional[str] = None
         self._ocean_version: Optional[str] = None
         self.event_id = ""
-        self.sync_state = SyncState.QUEUED
+        self.sync_state = SyncState.PENDING
 
     @property
     def event_id(self) -> str:
@@ -163,9 +157,6 @@ class Metrics:
         return self.metrics_settings.enabled
 
     def load_metrics(self) -> None:
-        if not self.enabled:
-            return None
-
         # Load all registered metrics
         for name, (_, description, labels) in _metrics_registry.items():
             self.metrics[name] = Gauge(
@@ -173,8 +164,6 @@ class Metrics:
             )
 
     def get_metric(self, name: str, labels: list[str]) -> Gauge | EmptyMetric:
-        if not self.enabled:
-            return EmptyMetric()
         metrics = self.metrics.get(name)
         if not metrics:
             return EmptyMetric()
@@ -188,9 +177,6 @@ class Metrics:
             labels (list[str]): The labels to apply to the metric.
             value (float): The value to inc.
         """
-        if not self.enabled:
-            return None
-
         self.get_metric(name, labels).inc(value)
 
     def set_metric(self, name: str, labels: list[str], value: float) -> None:
@@ -201,9 +187,6 @@ class Metrics:
             labels (list[str]): The labels to apply to the metric.
             value (float): The value to set.
         """
-        if not self.enabled:
-            return None
-
         self.get_metric(name, labels).set(value)
 
     def initialize_metrics(self, kind_blockes: list[str]) -> None:
@@ -271,15 +254,39 @@ class Metrics:
             self.registry
         ).decode()
 
-    async def flush(
-        self, metric_name: Optional[str] = None, kind: Optional[str] = None
+    async def report_sync_metrics(
+        self, metric_name: Optional[str] = None, kinds: Optional[list[str]] = None
     ) -> None:
-        if not self.enabled:
+        if kinds is None:
             return None
 
-        if not self.metrics_settings.webhook_url:
+        metrics = []
+
+        for kind in kinds:
+            metric = self.generate_metrics(metric_name, kind)
+            metrics.extend(metric)
+
+        try:
+            await self.port_client.post_integration_sync_metrics(metrics)
+        except Exception as e:
+            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
+    ) -> None:
+        metrics = self.generate_metrics(metric_name, kind)
+        if not metrics:
             return None
 
+        try:
+            for metric in metrics:
+                await self.port_client.put_integration_sync_metrics(metric)
+        except Exception as e:
+            logger.error(f"Error putting metrics: {e}", metrics=metrics)
+
+    def generate_metrics(
+        self, metric_name: Optional[str] = None, kind: Optional[str] = None
+    ) -> list[dict[str, Any]]:
         try:
             latest_raw = self.generate_latest()
             metric_families = prometheus_client.parser.text_string_to_metric_families(
@@ -318,27 +325,54 @@ class Metrics:
 
             # If no metrics were filtered, exit early
             if not metrics_dict.get("kind", {}):
-                return None
+                return []
 
+            events = []
             for kind_key, metrics in metrics_dict.get("kind", {}).items():
                 # Skip if we're filtering by kind and this isn't the requested kind
                 if kind and kind_key != kind:
                     continue
 
                 event = {
-                    "integration_type": self.integration_configuration.type,
-                    "integration_identifier": self.integration_configuration.identifier,
-                    "integration_version": self.integration_version,
-                    "ocean_version": self.ocean_version,
-                    "kind_identifier": kind_key,
-                    "kind": "-".join(kind_key.split("-")[:-1]),
-                    "event_id": self.event_id,
-                    "sync_state": self.sync_state,
+                    "integrationType": self.integration_configuration.type,
+                    "integrationIdentifier": self.integration_configuration.identifier,
+                    "integrationVersion": self.integration_version,
+                    "oceanVersion": self.ocean_version,
+                    "kindIdentifier": kind_key,
+                    "kind": (
+                        "-".join(kind_key.split("-")[:-1])
+                        if "-" in kind_key
+                        else kind_key
+                    ),
+                    "kindIndex": 0 if kind_key == "__runtime__" else int(kind_key[-1]),
+                    "eventId": self.event_id,
+                    "syncState": self.sync_state,
                     "metrics": metrics,
                 }
-                logger.info(f"Sending metrics to webhook {kind_key}: {event}")
+                events.append(event)
+            return events
+        except Exception as e:
+            logger.error(f"Error sending metrics to webhook: {e}")
+            return []
+
+    async def send_metrics_to_webhook(
+        self, metric_name: Optional[str] = None, kind: Optional[str] = None
+    ) -> None:
+        try:
+            if not self.enabled:
+                return None
+
+            if not self.metrics_settings.webhook_url:
+                return None
+
+            metrics = self.generate_metrics(metric_name, kind)
+            if not metrics:
+                return None
+
+            for metric in metrics:
+                logger.info(f"Sending metrics to webhook {metric['kind']}: {metric}")
                 await AsyncClient().post(
-                    url=self.metrics_settings.webhook_url, json=event
+                    url=self.metrics_settings.webhook_url, json=metric
                 )
         except Exception as e:
             logger.error(f"Error sending metrics to webhook: {e}")

port_ocean/helpers/metric/utils.py

@@ -11,8 +11,6 @@ def TimeMetric(phase: str) -> Any:
 
         @wraps(func)
         async def wrapper(*args: Any, **kwargs: dict[Any, Any]) -> Any:
-            if not ocean.metrics.enabled:
-                return await func(*args, **kwargs)
             start = time.monotonic()
             res = await func(*args, **kwargs)
             end = time.monotonic()

port_ocean/ocean.py

@@ -57,9 +57,20 @@ class Ocean:
             *self.config.get_sensitive_fields_data()
         )
         self.integration_router = integration_router or APIRouter()
+
+        self.port_client = PortClient(
+            base_url=self.config.port.base_url,
+            client_id=self.config.port.client_id,
+            client_secret=self.config.port.client_secret,
+            integration_identifier=self.config.integration.identifier,
+            integration_type=self.config.integration.type,
+            integration_version=__integration_version__,
+        )
+
         self.metrics = port_ocean.helpers.metric.metric.Metrics(
             metrics_settings=self.config.metrics,
             integration_configuration=self.config.integration,
+            port_client=self.port_client,
         )
 
         self.webhook_manager = LiveEventsProcessorManager(
@@ -69,14 +80,6 @@ class Ocean:
             max_wait_seconds_before_shutdown=self.config.max_wait_seconds_before_shutdown,
         )
 
-        self.port_client = PortClient(
-            base_url=self.config.port.base_url,
-            client_id=self.config.port.client_id,
-            client_secret=self.config.port.client_secret,
-            integration_identifier=self.config.integration.identifier,
-            integration_type=self.config.integration.type,
-            integration_version=__integration_version__,
-        )
         self.integration = (
             integration_class(ocean) if integration_class else BaseIntegration(ocean)
         )

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

@@ -1,6 +1,7 @@
 from graphlib import CycleError
-from typing import Any
+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
@@ -24,6 +25,8 @@ 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
@@ -36,7 +39,47 @@ def mock_sync_raw_mixin(
     sync_raw_mixin._entity_processor = mock_entity_processor
     sync_raw_mixin._entities_state_applier = mock_entities_state_applier
     sync_raw_mixin._port_app_config_handler = mock_port_app_config_handler
-    sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([{}], []))  # type: ignore
+
+    # Create raw data that matches the entity structure
+    raw_data = [
+        {
+            "id": "entity_1",
+            "name": "Entity 1",
+            "service": "entity_3",
+            "web_url": "https://example.com/entity1",
+        },
+        {
+            "id": "entity_2",
+            "name": "Entity 2",
+            "service": "entity_4",
+            "web_url": "https://example.com/entity2",
+        },
+        {
+            "id": "entity_3",
+            "name": "Entity 3",
+            "service": "",
+            "web_url": "https://example.com/entity3",
+        },
+        {
+            "id": "entity_4",
+            "name": "Entity 4",
+            "service": "entity_3",
+            "web_url": "https://example.com/entity4",
+        },
+        {
+            "id": "entity_5",
+            "name": "Entity 5",
+            "service": "entity_1",
+            "web_url": "https://example.com/entity5",
+        },
+    ]
+
+    # Create an async generator that yields the raw data
+    async def raw_results_generator() -> AsyncGenerator[list[dict[str, Any]], None]:
+        yield raw_data
+
+    # Return a list containing the async generator and an empty error list
+    sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([raw_results_generator()], []))  # type: ignore
     sync_raw_mixin._entity_processor.parse_items = AsyncMock(return_value=MagicMock())  # type: ignore
 
     return sync_raw_mixin
@@ -51,9 +94,33 @@ 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,
+    mock_ocean: Ocean,
 ) -> None:
     entities_params = [
         ("entity_1", "service", {"service": "entity_1"}, True),
@@ -62,8 +129,14 @@ async def test_sync_raw_mixin_self_dependency(
     entities = [create_entity(*entity_param) for entity_param in entities_params]
 
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
@@ -105,6 +178,50 @@ async def test_sync_raw_mixin_self_dependency(
                     for call in mock_order_by_entities_dependencies.call_args_list
                 ] == [entity for entity in entities if entity.identifier == "entity_1"]
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 3
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 1
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 1
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_circular_dependency(
@@ -117,8 +234,14 @@ async def test_sync_raw_mixin_circular_dependency(
     entities = [create_entity(*entity_param) for entity_param in entities_params]
 
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
@@ -183,11 +306,56 @@ async def test_sync_raw_mixin_circular_dependency(
                     == 2
                 )
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 3
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 0
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_dependency(
     mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
 ) -> None:
+    # Create entities with more realistic data
     entities_params = [
         ("entity_1", "service", {"service": "entity_3"}, True),
         ("entity_2", "service", {"service": "entity_4"}, True),
@@ -197,10 +365,18 @@ async def test_sync_raw_mixin_dependency(
     ]
     entities = [create_entity(*entity_param) for entity_param in entities_params]
 
+    # Create a more realistic CalculationResult mock
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
+    # Mock the parse_items method to return our realistic mock
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
     mock_order_by_entities_dependencies = MagicMock(
@@ -270,6 +446,44 @@ async def test_sync_raw_mixin_dependency(
                     "entity_3-entity_1-entity_4-entity_5-entity_2",
                 )
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 0
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 5
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_register_raw(
@@ -670,6 +884,7 @@ async def test_register_resource_raw_skip_event_type_http_request_upsert_called_
 async def test_on_resync_start_hooks_are_called(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
+    mock_ocean: Ocean,
 ) -> None:
     # Setup
     resync_start_called = False
@@ -679,7 +894,9 @@ async def test_on_resync_start_hooks_are_called(
         resync_start_called = True
 
     mock_sync_raw_mixin.on_resync_start(on_resync_start)
-
+    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
     # Execute
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
         event.port_app_config = mock_port_app_config
@@ -707,6 +924,9 @@ async def test_on_resync_complete_hooks_are_called_on_success(
 
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
     mock_ocean.port_client.search_entities.return_value = []  # type: ignore
+    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
 
     # Execute
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
@@ -777,6 +997,9 @@ async def test_multiple_on_resync_start_on_resync_complete_hooks_called_in_order
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete2)
     mock_ocean.port_client.search_entities.return_value = []  # type: ignore
 
+    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
     # Execute
     async with event_context(EventType.RESYNC, trigger_type="machine") as event:
         event.port_app_config = mock_port_app_config
@@ -798,6 +1021,7 @@ async def test_multiple_on_resync_start_on_resync_complete_hooks_called_in_order
 async def test_on_resync_start_hook_error_prevents_resync(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
+    mock_ocean: Ocean,
 ) -> None:
     # Setup
     resync_complete_called = False
@@ -812,7 +1036,9 @@ async def test_on_resync_start_hook_error_prevents_resync(
 
     mock_sync_raw_mixin.on_resync_start(on_resync_start)
     mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
-
+    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
+    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
     original_get_resource_raw_results = mock_sync_raw_mixin._get_resource_raw_results
 
     async def track_resync(*args: Any, **kwargs: Any) -> Any:

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

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

@@ -53,7 +53,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=tvuP8jxgbDyTwGfp8hd0-NXfnsMjZFJXDEDzXroctnY,9381
+port_ocean/clients/port/mixins/integrations.py,sha256=QuPZ4MC8FtJ-3FKbm0CqJ5TOxtSyaQLR_rsJ-p7-y_Q,11115
 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
@@ -87,7 +87,7 @@ port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
 port_ocean/core/handlers/entities_state_applier/base.py,sha256=5wHL0icfFAYRPqk8iV_wN49GdJ3aRUtO8tumSxBi4Wo,2268
 port_ocean/core/handlers/entities_state_applier/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=Glw-iSZvN0WaaQL3qfOSb9uEXcy88_mSOzifMLNhhOc,6254
+port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=CcrKlFG0eAvUqWit_2SjDrYfTDmMlr4PPSiPBIw7qhM,6367
 port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha256=1zncwCbE-Gej0xaWKlzZgoXxOBe9bgs_YxlZ8QW3NdI,1751
 port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=lyv6xKzhYfd6TioUgR3AVRSJqj7JpAaj1LxxU2xAqeo,1720
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
@@ -101,7 +101,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=K3E7MfO7SDO6SYRb_MPb4Cu3LTEumfYLHnhYV8IE0kY,3606
+port_ocean/core/handlers/resync_state_updater/updater.py,sha256=KZ55dubVYmFHxUOzdUFBPGLQhQSVBiRAoyk3R-NKKRU,3819
 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
@@ -113,7 +113,7 @@ 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=ezjfpxZJ-0IjxppP6nKu4lSWjsh_8HPNghSgsQRayR8,29100
+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/ocean_types.py,sha256=4VipWFOHEh_d9LmWewQccwx1p2dtrRYW0YURVgNsAjo,1398
@@ -131,15 +131,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=Eg8t7k3hDumnUHe2TvE5xus3cWoROwJPjoviW4QrGoE,11440
-port_ocean/helpers/metric/utils.py,sha256=_qj9-PfsrMHoXVscEsIdnylLVZJnupg8ofHYaKc5-t8,874
+port_ocean/helpers/metric/metric.py,sha256=F7R5JGmyGPsvqBY7wlDfOc15GX28-Kslbw99Y0aETv0,12785
+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
 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=XmPmnjo-2oMZGvCLwIxPxwVNzXXzACzVR4JmlkXEOKY,7418
+port_ocean/ocean.py,sha256=8yUw9pDBGkqBHza_PKtINz_7G69Ia6o1m8H-SvlKOOk,7462
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=COoRSmLG4hbsjIW5DzhV0NYVegI9xHd1POv6sg4U1No,2217
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -155,7 +155,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=RTkHU2QS9f-Lt3u0OCBPPEeiaM2_9h5vOQxqLnrbQro,33560
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=ZjAWXpheHa61M9nIj4FUGKt9xMeI4Z1AvE6Nko-uru8,43482
 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
@@ -188,8 +188,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.22.9.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.22.9.dist-info/METADATA,sha256=H6ErJ-lhawBgcqSnlgMOEgOz-Nsc5GAh-p0spV6VExY,6764
-port_ocean-0.22.9.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.22.9.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.22.9.dist-info/RECORD,,
+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,,