port-ocean 0.21.4__py3-none-any.whl → 0.22.0__py3-none-any.whl

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

@@ -1,9 +1,6 @@
-from contextlib import asynccontextmanager
 from graphlib import CycleError
-from typing import Any, AsyncGenerator
+from typing import Any
 
-from httpx import Response
-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
@@ -11,12 +8,8 @@ from unittest.mock import MagicMock, AsyncMock, patch
 from port_ocean.ocean import Ocean
 from port_ocean.context.ocean import PortOceanContext
 from port_ocean.core.handlers.port_app_config.models import (
-    EntityMapping,
-    MappingsConfig,
     PortAppConfig,
-    PortResourceConfig,
     ResourceConfig,
-    Selector,
 )
 from port_ocean.core.integrations.mixins import SyncRawMixin
 from port_ocean.core.handlers.entities_state_applier.port.applier import (
@@ -26,148 +19,11 @@ from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
     JQEntityProcessor,
 )
 from port_ocean.core.models import Entity
-from port_ocean.context.event import EventContext, event_context, EventType
+from port_ocean.context.event import event_context, EventType
 from port_ocean.clients.port.types import UserAgentType
-from port_ocean.context.ocean import ocean
 from dataclasses import dataclass
 from typing import List, Optional
-
-
-@pytest.fixture
-def mock_port_client(mock_http_client: MagicMock) -> PortClient:
-    mock_port_client = PortClient(
-        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
-    )
-    mock_port_client.auth = AsyncMock()
-    mock_port_client.auth.headers = AsyncMock(
-        return_value={
-            "Authorization": "test",
-            "User-Agent": "test",
-        }
-    )
-
-    mock_port_client.search_entities = AsyncMock(return_value=[])  # type: ignore
-    mock_port_client.client = mock_http_client
-    return mock_port_client
-
-
-@pytest.fixture
-def mock_http_client() -> MagicMock:
-    mock_http_client = MagicMock()
-    mock_upserted_entities = []
-
-    async def post(url: str, *args: Any, **kwargs: Any) -> Response:
-        entity = kwargs.get("json", {})
-        if entity.get("properties", {}).get("mock_is_to_fail", {}):
-            return Response(
-                404, headers=MagicMock(), json={"ok": False, "error": "not_found"}
-            )
-
-        mock_upserted_entities.append(
-            f"{entity.get('identifier')}-{entity.get('blueprint')}"
-        )
-        return Response(
-            200,
-            json={
-                "entity": {
-                    "identifier": entity.get("identifier"),
-                    "blueprint": entity.get("blueprint"),
-                }
-            },
-        )
-
-    mock_http_client.post = AsyncMock(side_effect=post)
-    return mock_http_client
-
-
-@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
-
-        return ocean_mock
-
-
-@pytest.fixture
-def mock_context(mock_ocean: Ocean) -> PortOceanContext:
-    context = PortOceanContext(mock_ocean)
-    ocean._app = context.app
-    return context
-
-
-@pytest.fixture
-def mock_port_app_config() -> PortAppConfig:
-    return PortAppConfig(
-        enable_merge_entity=True,
-        delete_dependent_entities=True,
-        create_missing_related_entities=False,
-        resources=[
-            ResourceConfig(
-                kind="project",
-                selector=Selector(query="true"),
-                port=PortResourceConfig(
-                    entity=MappingsConfig(
-                        mappings=EntityMapping(
-                            identifier=".id | tostring",
-                            title=".name",
-                            blueprint='"service"',
-                            properties={"url": ".web_url"},
-                            relations={},
-                        )
-                    )
-                ),
-            )
-        ],
-    )
-
-
-@pytest.fixture
-def mock_port_app_config_handler(mock_port_app_config: PortAppConfig) -> MagicMock:
-    handler = MagicMock()
-
-    async def get_config(use_cache: bool = True) -> Any:
-        return mock_port_app_config
-
-    handler.get_port_app_config = get_config
-    return handler
-
-
-@pytest.fixture
-def mock_entity_processor(mock_context: PortOceanContext) -> JQEntityProcessor:
-    return JQEntityProcessor(mock_context)
-
-
-@pytest.fixture
-def mock_resource_config() -> ResourceConfig:
-    resource = ResourceConfig(
-        kind="service",
-        selector=Selector(query="true"),
-        port=PortResourceConfig(
-            entity=MappingsConfig(
-                mappings=EntityMapping(
-                    identifier=".id",
-                    title=".name",
-                    blueprint='"service"',
-                    properties={"url": ".web_url"},
-                    relations={},
-                )
-            )
-        ),
-    )
-    return resource
-
-
-@pytest.fixture
-def mock_entities_state_applier(
-    mock_context: PortOceanContext,
-) -> HttpEntitiesStateApplier:
-    return HttpEntitiesStateApplier(mock_context)
+from port_ocean.tests.core.conftest import create_entity, no_op_event_context
 
 
 @pytest.fixture
@@ -189,27 +45,12 @@ def mock_sync_raw_mixin(
 @pytest.fixture
 def mock_sync_raw_mixin_with_jq_processor(
     mock_sync_raw_mixin: SyncRawMixin,
+    mock_context: PortOceanContext,
 ) -> SyncRawMixin:
-    mock_sync_raw_mixin._entity_processor = JQEntityProcessor(mock_context)  # type: ignore
+    mock_sync_raw_mixin._entity_processor = JQEntityProcessor(mock_context)
     return mock_sync_raw_mixin
 
 
-@asynccontextmanager
-async def no_op_event_context(
-    existing_event: EventContext,
-) -> AsyncGenerator[EventContext, None]:
-    yield existing_event
-
-
-def create_entity(
-    id: str, blueprint: str, relation: dict[str, str], is_to_fail: bool
-) -> Entity:
-    entity = Entity(identifier=id, blueprint=blueprint)
-    entity.relations = relation
-    entity.properties = {"mock_is_to_fail": is_to_fail}
-    return entity
-
-
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_self_dependency(
     mock_sync_raw_mixin: SyncRawMixin,

port_ocean/tests/core/handlers/webhook/test_processor_manager.py

@@ -12,6 +12,7 @@ from port_ocean.core.handlers.webhook.webhook_event import (
     EventPayload,
 )
 from fastapi import APIRouter
+from port_ocean.core.integrations.mixins.handler import HandlerMixin
 from port_ocean.utils.signal import SignalHandler
 from typing import Dict, Any
 import asyncio
@@ -19,7 +20,7 @@ from fastapi.testclient import TestClient
 from fastapi import FastAPI
 from port_ocean.context.ocean import PortOceanContext
 from unittest.mock import AsyncMock
-from port_ocean.context.event import event_context, EventType
+from port_ocean.context.event import EventContext, event_context, EventType
 from port_ocean.context.ocean import ocean
 from unittest.mock import MagicMock, patch
 from httpx import Response
@@ -571,6 +572,16 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessed_en
         "sync_raw_results",
         patched_export_single_resource,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -589,12 +600,7 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessed_en
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -685,6 +691,16 @@ async def test_integrationTest_postRequestSent_reachedTimeout_entityNotUpserted(
         "_process_single_event",
         patched_process_single_event,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -703,12 +719,7 @@ async def test_integrationTest_postRequestSent_reachedTimeout_entityNotUpserted(
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -802,6 +813,16 @@ async def test_integrationTest_postRequestSent_noMatchingHandlers_entityNotUpser
         "_extract_matching_processors",
         patched_extract_matching_processors,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -819,13 +840,7 @@ async def test_integrationTest_postRequestSent_noMatchingHandlers_entityNotUpser
     client = TestClient(mock_context.app.fast_api_app)
 
     test_payload = {"test": "data"}
-
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -982,6 +997,16 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
         "sync_raw_results",
         patched_export_single_resource,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -1004,12 +1029,7 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -1112,6 +1132,16 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
         "sync_raw_results",
         patched_export_single_resource,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -1130,12 +1160,7 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -1242,6 +1267,16 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
         "_process_webhook_request",
         patched_process_webhook_request,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -1260,12 +1295,7 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )
@@ -1381,6 +1411,16 @@ async def test_integrationTest_postRequestSent_oneProcessorThrowsException_onlyS
         "sync_raw_results",
         patched_export_single_resource,
     )
+    monkeypatch.setattr(
+        HandlerMixin,
+        "port_app_config_handler",
+        AsyncMock(return_value=mock_port_app_config),
+    )
+    monkeypatch.setattr(
+        EventContext,
+        "port_app_config",
+        mock_port_app_config,
+    )
     test_path = "/webhook-test"
     mock_context.app.integration = BaseIntegration(ocean)
     mock_context.app.webhook_manager = LiveEventsProcessorManager(
@@ -1401,12 +1441,7 @@ async def test_integrationTest_postRequestSent_oneProcessorThrowsException_onlyS
 
     test_payload = {"test": "data"}
 
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
-        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
-        event.port_app_config = (
-            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
-        )
-
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
         response = client.post(
             test_path, json=test_payload, headers={"Content-Type": "application/json"}
         )

port_ocean/tests/test_metric.py

@@ -0,0 +1,180 @@
+import ast
+import pytest
+
+
+@pytest.mark.metric
+@pytest.mark.skip(reason="Skipping metric test until we have a way to test the metrics")
+def test_metrics() -> None:
+    """
+    Test that the metrics logged in /tmp/ocean/metric.log match expected values.
+    """
+
+    log_path = "/tmp/ocean/metric.log"
+    delay = 2
+    batch_size = 400
+    total_objects = 2000
+    magic_string = "prometheus metrics |"
+
+    # Read the file
+    with open(log_path, "r") as file:
+        content = file.read()
+
+    # Ensure the magic string is present in the content
+    assert magic_string in content, f"'{magic_string}' not found in {log_path}"
+
+    # Isolate and parse the JSON object after the magic string
+    start_idx = content.rfind(magic_string)
+    content_after_magic = content[start_idx + len(magic_string) :]
+    obj = ast.literal_eval(content_after_magic)
+
+    # ----------------------------------------------------------------------------
+    # 1. Validate Extract Duration (using original delay/batch_size logic)
+    # ----------------------------------------------------------------------------
+    num_batches = total_objects / batch_size  # e.g., 2000 / 400 = 5
+    expected_min_extract_duration = num_batches * delay  # e.g., 5 * 2 = 10
+
+    # Check "fake-person-1" extract duration is > expected_min_extract_duration
+    actual_extract_duration = obj.get("duration_seconds__fake-person-1__extract", 0)
+    assert round(actual_extract_duration) > round(expected_min_extract_duration), (
+        f"Extract duration {actual_extract_duration} not greater than "
+        f"{expected_min_extract_duration}"
+    )
+
+    # ----------------------------------------------------------------------------
+    # 2. Check Durations for Both "fake-person-1" and "fake-department-0"
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    transform_duration_p1 = obj.get("duration_seconds__fake-person-1__transform", 0)
+    load_duration_p1 = obj.get("duration_seconds__fake-person-1__load", 0)
+    assert (
+        transform_duration_p1 > 0
+    ), f"Expected transform duration > 0, got {transform_duration_p1}"
+    assert load_duration_p1 > 0, f"Expected load duration > 0, got {load_duration_p1}"
+
+    # -- fake-department-0
+    extract_duration_dept0 = obj.get("duration_seconds__fake-department-0__extract", 0)
+    transform_duration_dept0 = obj.get(
+        "duration_seconds__fake-department-0__transform", 0
+    )
+    load_duration_dept0 = obj.get("duration_seconds__fake-department-0__load", 0)
+
+    assert (
+        extract_duration_dept0 > 0
+    ), f"Expected department extract duration > 0, got {extract_duration_dept0}"
+    assert (
+        transform_duration_dept0 > 0
+    ), f"Expected department transform duration > 0, got {transform_duration_dept0}"
+    assert (
+        load_duration_dept0 > 0
+    ), f"Expected department load duration > 0, got {load_duration_dept0}"
+
+    # Optionally, check the "init__top_sort" duration too, if it's relevant:
+    init_top_sort = obj.get("duration_seconds__init__top_sort", 0)
+    assert init_top_sort >= 0, f"Expected init__top_sort >= 0, got {init_top_sort}"
+
+    # ----------------------------------------------------------------------------
+    # 3. Check Object Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    person_extract_count = obj.get("object_count__fake-person-1__extract", 0)
+    person_load_count = obj.get("object_count__fake-person-1__load", 0)
+    assert person_extract_count == 2000.0, (
+        f"Expected object_count__fake-person-1__extract=2000.0, "
+        f"got {person_extract_count}"
+    )
+    assert person_load_count == 4000.0, (
+        f"Expected object_count__fake-person-1__load=4000.0, "
+        f"got {person_load_count}"
+    )
+
+    # -- fake-department-0
+    dept_extract_count = obj.get("object_count__fake-department-0__extract", 0)
+    dept_load_count = obj.get("object_count__fake-department-0__load", 0)
+    assert dept_extract_count == 5.0, (
+        f"Expected object_count__fake-department-0__extract=5.0, "
+        f"got {dept_extract_count}"
+    )
+    assert dept_load_count == 10.0, (
+        f"Expected object_count__fake-department-0__load=10.0, "
+        f"got {dept_load_count}"
+    )
+
+    # ----------------------------------------------------------------------------
+    # 4. Check Input/Upserted Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    input_count_p1 = obj.get("input_count__fake-person-1__load", 0)
+    upserted_count_p1 = obj.get("upserted_count__fake-person-1__load", 0)
+    assert (
+        input_count_p1 == 2000.0
+    ), f"Expected input_count__fake-person-1__load=2000.0, got {input_count_p1}"
+    assert (
+        upserted_count_p1 == 2000.0
+    ), f"Expected upserted_count__fake-person-1__load=2000.0, got {upserted_count_p1}"
+
+    # -- fake-department-0
+    input_count_dept0 = obj.get("input_count__fake-department-0__load", 0)
+    upserted_count_dept0 = obj.get("upserted_count__fake-department-0__load", 0)
+    assert (
+        input_count_dept0 == 5.0
+    ), f"Expected input_count__fake-department-0__load=5.0, got {input_count_dept0}"
+    assert (
+        upserted_count_dept0 == 5.0
+    ), f"Expected upserted_count__fake-department-0__load=5.0, got {upserted_count_dept0}"
+
+    # ----------------------------------------------------------------------------
+    # 5. Check Error and Failed Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    error_count_p1 = obj.get("error_count__fake-person-1__load", 0)
+    failed_count_p1 = obj.get("failed_count__fake-person-1__load", 0)
+    assert (
+        error_count_p1 == 0.0
+    ), f"Expected error_count__fake-person-1__load=0.0, got {error_count_p1}"
+    assert (
+        failed_count_p1 == 0.0
+    ), f"Expected failed_count__fake-person-1__load=0.0, got {failed_count_p1}"
+
+    # -- fake-department-0
+    error_count_dept0 = obj.get("error_count__fake-department-0__load", 0)
+    failed_count_dept0 = obj.get("failed_count__fake-department-0__load", 0)
+    assert (
+        error_count_dept0 == 0.0
+    ), f"Expected error_count__fake-department-0__load=0.0, got {error_count_dept0}"
+    assert (
+        failed_count_dept0 == 0.0
+    ), f"Expected failed_count__fake-department-0__load=0.0, got {failed_count_dept0}"
+
+    # ----------------------------------------------------------------------------
+    # 6. Check HTTP Request Counts (200s)
+    # ----------------------------------------------------------------------------
+    # Example: we confirm certain request counters match the sample data provided:
+    assert (
+        obj.get(
+            "http_requests_count__http://host.docker.internal:5555/v1/auth/access_token__init__load__200",
+            0,
+        )
+        == 1.0
+    ), "Expected 1.0 for auth access_token 200 requests"
+    assert (
+        obj.get(
+            "http_requests_count__http://host.docker.internal:5555/v1/integration/smoke-test-integration__init__load__200",
+            0,
+        )
+        == 5.0
+    ), "Expected 5.0 for integration/smoke-test-integration 200 requests"
+    assert (
+        obj.get(
+            "http_requests_count__http://localhost:8000/integration/department/hr/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200",
+            0,
+        )
+        == 1.0
+    ), "Expected 1.0 for hr/employees?limit=-1 extract 200 requests"
+    expected_requests = {
+        "http_requests_count__http://localhost:8000/integration/department/marketing/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200": 1.0,
+        "http_requests_count__http://localhost:8000/integration/department/finance/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200": 1.0,
+    }
+    for key, expected_val in expected_requests.items():
+        assert (
+            obj.get(key, 0) == expected_val
+        ), f"Expected {expected_val} for '{key}', got {obj.get(key)}"

port_ocean/utils/async_http.py

@@ -11,7 +11,10 @@ _http_client: LocalStack[httpx.AsyncClient] = LocalStack()
 def _get_http_client_context() -> httpx.AsyncClient:
     client = _http_client.top
     if client is None:
-        client = OceanAsyncClient(RetryTransport, timeout=ocean.config.client_timeout)
+        client = OceanAsyncClient(
+            RetryTransport,
+            timeout=ocean.config.client_timeout,
+        )
         _http_client.push(client)
 
     return client

{port_ocean-0.21.4.dist-info → port_ocean-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.21.4
+Version: 0.22.0
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port
@@ -31,6 +31,7 @@ Requires-Dist: httpx (>=0.24.1,<0.28.0)
 Requires-Dist: jinja2-time (>=0.2.0,<0.3.0) ; extra == "cli"
 Requires-Dist: jq (>=1.8.0,<2.0.0)
 Requires-Dist: loguru (>=0.7.0,<0.8.0)
+Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: pydantic[dotenv] (>=1.10.8,<2.0.0)
 Requires-Dist: pydispatcher (>=2.0.7,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)