port-ocean 0.26.2__py3-none-any.whl → 0.27.0__py3-none-any.whl

integrations/_infra/Dockerfile.Deb

@@ -27,6 +27,7 @@ RUN mkdir -p /tmp/ocean
 ARG INTEGRATION_VERSION
 ARG BUILD_CONTEXT
 ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
+ARG OAUTH_CONFIG_DIR=/app/.config
 
 ENV LIBRDKAFKA_VERSION=2.8.2 \
     PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
@@ -34,6 +35,9 @@ ENV LIBRDKAFKA_VERSION=2.8.2 \
 RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 RUN chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
 
+RUN mkdir -p ${OAUTH_CONFIG_DIR}
+RUN chown -R ocean:appgroup ${OAUTH_CONFIG_DIR}
+
 RUN apt-get update \
     && apt-get install -y \
         ca-certificates \

port_ocean/config/settings.py

@@ -9,6 +9,7 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanModel, BaseOceanSettings
 from port_ocean.core.event_listener import EventListenerSettingsType
+
 from port_ocean.core.models import (
     CachingStorageMode,
     CreatePortResourcesOrigin,
@@ -88,6 +89,7 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     event_listener: EventListenerSettingsType = Field(
         default=cast(EventListenerSettingsType, {"type": "POLLING"})
     )
+    event_workers_count: int = 1
     # If an identifier or type is not provided, it will be generated based on the integration name
     integration: IntegrationSettings = Field(
         default_factory=lambda: IntegrationSettings(type="", identifier="")

port_ocean/core/handlers/queue/__init__.py

@@ -1,4 +1,5 @@
 from .abstract_queue import AbstractQueue
 from .local_queue import LocalQueue
+from .group_queue import GroupQueue
 
-__all__ = ["AbstractQueue", "LocalQueue"]
+__all__ = ["AbstractQueue", "LocalQueue", "GroupQueue"]

port_ocean/core/handlers/queue/abstract_queue.py

@@ -7,6 +7,9 @@ T = TypeVar("T")
 class AbstractQueue(ABC, Generic[T]):
     """Abstract interface for queues"""
 
+    def __init__(self, name: str | None = None):
+        pass
+
     @abstractmethod
     async def put(self, item: T) -> None:
         """Put an item into the queue"""
@@ -22,6 +25,11 @@ class AbstractQueue(ABC, Generic[T]):
         """Wait for all items to be processed"""
         pass
 
+    @abstractmethod
+    async def size(self) -> int:
+        """Size of the queue"""
+        pass
+
     @abstractmethod
     async def commit(self) -> None:
         """Mark item as processed"""

port_ocean/core/handlers/queue/group_queue.py

@@ -0,0 +1,138 @@
+import asyncio
+from collections import defaultdict, deque
+import time
+from typing import Deque, Dict, Optional, Set, TypeVar, Any
+from contextvars import ContextVar
+
+from loguru import logger
+
+from .abstract_queue import AbstractQueue
+
+T = TypeVar("T")
+MaybeStr = str | None
+
+_NO_GROUP = object()
+_current_group: ContextVar[Any] = ContextVar("current_group", default=_NO_GROUP)
+
+
+class GroupQueue(AbstractQueue[T]):
+    """Queue with exclusive processing per group."""
+
+    def __init__(
+        self,
+        group_key: MaybeStr = None,
+        name: MaybeStr = None,
+        lock_timeout: float = 300,
+    ):
+        super().__init__(name)
+        self.group_key = group_key
+        self._queues: Dict[MaybeStr, Deque[T]] = defaultdict(deque)
+        self._locked: Set[MaybeStr] = set()
+        self._queue_not_empty = asyncio.Condition()
+        self.lock_timeout = lock_timeout
+        self._lock_timestamps: Dict[MaybeStr, float] = {}
+        self._timeout_task: Optional[asyncio.Task[None]] = None
+
+    async def _background_timeout_check(self) -> None:
+        """Periodically release locks that have timed out."""
+        while True:
+            try:
+                await asyncio.sleep(self.lock_timeout / 4)
+                async with self._queue_not_empty:
+                    await self._release_expired_locks()
+            except asyncio.CancelledError:
+                break
+
+    def _extract_group_key(self, item: T) -> MaybeStr:
+        """Extract the group key from an item."""
+        if self.group_key is None:
+            return None
+        if not hasattr(item, self.group_key):
+            raise ValueError(
+                f"Item {item!r} lacks attribute '{self.group_key}' required for grouping"
+            )
+        return getattr(item, self.group_key)
+
+    async def put(self, item: T) -> None:
+        """Add item to its group's queue."""
+        group_key = self._extract_group_key(item)
+        async with self._queue_not_empty:
+            self._queues[group_key].append(item)
+            self._queue_not_empty.notify_all()
+
+    async def _release_expired_locks(self) -> None:
+        """Release locks that have exceeded the timeout."""
+        now = time.time()
+        expired_groups = []
+
+        for group, timestamp in list(self._lock_timestamps.items()):
+            if now - timestamp > self.lock_timeout:
+                expired_groups.append(group)
+                logger.warning(f"Releasing expired lock for group {group}")
+                self._locked.discard(group)
+                del self._lock_timestamps[group]
+
+        if expired_groups:
+            self._queue_not_empty.notify_all()
+
+    async def get(self) -> T:
+        """Get the next item from an unlocked group, locking that group."""
+        if self._timeout_task is None or self._timeout_task.done():
+            self._timeout_task = asyncio.create_task(self._background_timeout_check())
+
+        async with self._queue_not_empty:
+            while True:
+                await self._release_expired_locks()
+
+                for group, queue in self._queues.items():
+                    if queue and group not in self._locked:
+                        self._locked.add(group)
+                        self._lock_timestamps[group] = time.time()
+                        _current_group.set(group)
+                        return queue[0]
+
+                await self._queue_not_empty.wait()
+
+    async def commit(self) -> None:
+        """Remove the current item and unlock its group."""
+        group = _current_group.get()
+        if group is _NO_GROUP:
+            logger.warning("commit() called without active get()")
+            return
+
+        async with self._queue_not_empty:
+            queue = self._queues.get(group)
+            if queue:
+                queue.popleft()
+                if not queue:
+                    del self._queues[group]
+
+            self._locked.discard(group)
+            self._lock_timestamps.pop(group, None)
+            _current_group.set(_NO_GROUP)
+            self._queue_not_empty.notify_all()
+
+    async def teardown(self) -> None:
+        """Wait until all queues are empty and no groups are locked."""
+        async with self._queue_not_empty:
+            while any(self._queues.values()) or self._locked:
+                await self._queue_not_empty.wait()
+
+        if self._timeout_task and not self._timeout_task.done():
+            self._timeout_task.cancel()
+            try:
+                await self._timeout_task
+            except asyncio.CancelledError:
+                pass
+
+    async def size(self) -> int:
+        """Return total number of items across all groups."""
+        async with self._queue_not_empty:
+            return sum(len(queue) for queue in self._queues.values())
+
+    async def force_unlock_all(self) -> None:
+        """Force unlock all groups."""
+        async with self._queue_not_empty:
+            self._locked.clear()
+            self._lock_timestamps.clear()
+            self._queue_not_empty.notify_all()

port_ocean/core/handlers/queue/local_queue.py

@@ -23,3 +23,6 @@ class LocalQueue(AbstractQueue[T]):
 
     async def commit(self) -> None:
         self._queue.task_done()
+
+    async def size(self) -> int:
+        return self._queue.qsize()

port_ocean/core/handlers/webhook/processor_manager.py

@@ -1,4 +1,5 @@
-from typing import Dict, Type, Set
+from typing import Dict, Tuple, Type, Set, List
+
 from fastapi import APIRouter, Request
 from loguru import logger
 import asyncio
@@ -6,6 +7,7 @@ import asyncio
 from port_ocean.context.ocean import ocean
 from port_ocean.context.event import EventType, event_context
 from port_ocean.core.handlers.port_app_config.models import ResourceConfig
+from port_ocean.core.handlers.queue.abstract_queue import AbstractQueue
 from port_ocean.core.integrations.mixins.events import EventsMixin
 from port_ocean.core.integrations.mixins.live_events import LiveEventsMixin
 from port_ocean.exceptions.webhook_processor import WebhookEventNotSupportedError
@@ -15,7 +17,7 @@ from port_ocean.context.event import event
 
 from .abstract_webhook_processor import AbstractWebhookProcessor
 from port_ocean.utils.signal import SignalHandler
-from port_ocean.core.handlers.queue import AbstractQueue, LocalQueue
+from port_ocean.core.handlers.queue import LocalQueue
 
 
 class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
@@ -31,22 +33,103 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         self._router = router
         self._processors_classes: Dict[str, list[Type[AbstractWebhookProcessor]]] = {}
         self._event_queues: Dict[str, AbstractQueue[WebhookEvent]] = {}
-        self._webhook_processor_tasks: Set[asyncio.Task[None]] = set()
+        self._event_processor_tasks: Set[asyncio.Task[None]] = set()
         self._max_event_processing_seconds = max_event_processing_seconds
         self._max_wait_seconds_before_shutdown = max_wait_seconds_before_shutdown
         signal_handler.register(self.shutdown)
 
     async def start_processing_event_messages(self) -> None:
-        """Start processing events for all registered paths"""
+        """Start processing events for all registered paths with N workers each."""
         await self.initialize_handlers()
         loop = asyncio.get_event_loop()
+        config = ocean.integration.context.config
+
         for path in self._event_queues.keys():
+            for worker_id in range(0, config.event_workers_count):
+                task = loop.create_task(self._process_webhook_events(path, worker_id))
+                self._event_processor_tasks.add(task)
+                task.add_done_callback(self._event_processor_tasks.discard)
+
+    async def _process_webhook_events(self, path: str, worker_id: int) -> None:
+        """Process webhook events from the queue for a given path."""
+        queue = self._event_queues[path]
+        while True:
+            event = None
+            matching_processors: List[
+                Tuple[ResourceConfig, AbstractWebhookProcessor]
+            ] = []
             try:
-                task = loop.create_task(self.process_queue(path))
-                self._webhook_processor_tasks.add(task)
-                task.add_done_callback(self._webhook_processor_tasks.discard)
+                event = await queue.get()
+                with logger.contextualize(
+                    worker=worker_id,
+                    webhook_path=path,
+                    trace_id=event.trace_id,
+                ):
+                    async with event_context(
+                        EventType.HTTP_REQUEST,
+                        trigger_type="machine",
+                    ):
+
+                        await ocean.integration.port_app_config_handler.get_port_app_config(
+                            use_cache=False
+                        )
+                        matching_processors = await self._extract_matching_processors(
+                            event, path
+                        )
+
+                        processing_results = await asyncio.gather(
+                            *(
+                                self._process_single_event(proc, path, res)
+                                for res, proc in matching_processors
+                            ),
+                            return_exceptions=True,
+                        )
+
+                        successful_results: List[WebhookEventRawResults] = []
+                        failed_exceptions: List[Exception] = []
+
+                        for result in processing_results:
+                            if isinstance(result, WebhookEventRawResults):
+                                successful_results.append(result)
+                            elif isinstance(result, Exception):
+                                failed_exceptions.append(result)
+
+                        if successful_results:
+                            logger.info(
+                                "Successfully processed webhook events",
+                                success_count=len(successful_results),
+                                failure_count=len(failed_exceptions),
+                            )
+
+                        if failed_exceptions:
+                            logger.warning(
+                                "Some webhook events failed processing",
+                                failures=[str(e) for e in failed_exceptions],
+                            )
+
+                        await self.sync_raw_results(successful_results)
+
+            except asyncio.CancelledError:
+                logger.info(f"Worker {worker_id} for {path} shutting down")
+                for _, proc in matching_processors:
+                    await proc.cancel()
+                    self._timestamp_event_error(proc.event)
+                break
             except Exception as e:
-                logger.exception(f"Error starting queue processor for {path}: {str(e)}")
+                logger.exception(
+                    f"Unexpected error in worker {worker_id} for {path}: {e}"
+                )
+                for _, proc in matching_processors:
+                    self._timestamp_event_error(proc.event)
+            finally:
+                try:
+                    if event is not None:
+                        await queue.commit()
+
+                except Exception as e:
+                    logger.exception(
+                        f"Unexpected error in queue commit in worker {worker_id} for {path}: {e}"
+                    )
 
     async def _extract_matching_processors(
         self, webhook_event: WebhookEvent, path: str
@@ -91,70 +174,6 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         )
         return created_processors
 
-    async def process_queue(self, path: str) -> None:
-        """Process events for a specific path in order"""
-        while True:
-            matching_processors_with_resource: list[
-                tuple[ResourceConfig, AbstractWebhookProcessor]
-            ] = []
-            webhook_event: WebhookEvent | None = None
-            try:
-                queue = self._event_queues[path]
-                webhook_event = await queue.get()
-                with logger.contextualize(
-                    webhook_path=path, trace_id=webhook_event.trace_id
-                ):
-                    async with event_context(
-                        EventType.HTTP_REQUEST,
-                        trigger_type="machine",
-                    ):
-                        # This forces the Processor manager to fetch the latest port app config for each event
-                        await ocean.integration.port_app_config_handler.get_port_app_config(
-                            use_cache=False
-                        )
-                        matching_processors_with_resource = (
-                            await self._extract_matching_processors(webhook_event, path)
-                        )
-                        webhook_event_raw_results_for_all_resources = await asyncio.gather(
-                            *(
-                                self._process_single_event(processor, path, resource)
-                                for resource, processor in matching_processors_with_resource
-                            ),
-                            return_exceptions=True,
-                        )
-
-                        successful_raw_results: list[WebhookEventRawResults] = [
-                            result
-                            for result in webhook_event_raw_results_for_all_resources
-                            if isinstance(result, WebhookEventRawResults)
-                        ]
-
-                        if successful_raw_results:
-                            logger.info(
-                                "Exporting raw event results to entities",
-                                webhook_event_raw_results_for_all_resources_length=len(
-                                    successful_raw_results
-                                ),
-                            )
-                            await self.sync_raw_results(successful_raw_results)
-            except asyncio.CancelledError:
-                logger.info(f"Queue processor for {path} is shutting down")
-                for _, processor in matching_processors_with_resource:
-                    await processor.cancel()
-                    self._timestamp_event_error(processor.event)
-                break
-            except Exception as e:
-                logger.exception(
-                    f"Unexpected error in queue processor for {path}: {str(e)}"
-                )
-                for _, processor in matching_processors_with_resource:
-                    self._timestamp_event_error(processor.event)
-            finally:
-                if webhook_event:
-                    await self._event_queues[path].commit()
-                    # Prevents committing empty events for cases where we shutdown while processing
-                    webhook_event = None
-
     def _timestamp_event_error(self, event: WebhookEvent) -> None:
         """Timestamp an event as having an error"""
         event.set_timestamp(LiveEventTimestamp.FinishedProcessingWithError)
@@ -279,12 +298,14 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             methods=["POST"],
         )
 
-    async def _cancel_all_tasks(self) -> None:
-        """Cancel all webhook processor tasks"""
-        for task in self._webhook_processor_tasks:
+    async def _cancel_all_event_processors(
+        self,
+    ) -> None:
+        """Cancel all event processor tasks"""
+        for task in self._event_processor_tasks:
             task.cancel()
 
-        await asyncio.gather(*self._webhook_processor_tasks, return_exceptions=True)
+        await asyncio.gather(*self._event_processor_tasks, return_exceptions=True)
 
     async def shutdown(self) -> None:
         """Gracefully shutdown all queue processors"""
@@ -299,5 +320,3 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             )
         except asyncio.TimeoutError:
             logger.warning("Shutdown timed out waiting for queues to empty")
-
-        await self._cancel_all_tasks()

port_ocean/core/handlers/webhook/webhook_event.py

@@ -51,11 +51,13 @@ class WebhookEvent(LiveEvent):
         payload: EventPayload,
         headers: EventHeaders,
         original_request: Request | None = None,
+        group_id: str | None = None,
     ) -> None:
         self.trace_id = trace_id
         self.payload = payload
         self.headers = headers
         self._original_request = original_request
+        self.group_id = group_id
 
     @classmethod
     async def from_request(

port_ocean/tests/core/handlers/queue/test_group_queue.py

@@ -0,0 +1,681 @@
+import asyncio
+import pytest
+from dataclasses import dataclass
+from port_ocean.core.handlers.queue.group_queue import GroupQueue
+from typing import Any
+
+
+@dataclass
+class TestItem:
+    group_id: str
+    value: int
+
+
+@dataclass
+class TestItemNoGroup:
+    value: int
+
+
+class TestGroupQueue:
+    """Test suite for GroupQueue lock mechanism"""
+
+    @pytest.fixture
+    def queue_with_group_key(self) -> GroupQueue[Any]:
+        """Create a GroupQueue with group_key='group_id'"""
+        return GroupQueue(group_key="group_id", name="test_queue")
+
+    @pytest.fixture
+    def queue_no_group_key(self) -> GroupQueue[Any]:
+        """Create a GroupQueue without group_key (all items in same group)"""
+        return GroupQueue(group_key=None, name="test_queue_no_group")
+
+    @pytest.mark.asyncio
+    async def test_basic_lock_mechanism(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that getting an item locks the group"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item1 = TestItem(group_id="group_a", value=1)
+        item2 = TestItem(group_id="group_a", value=2)
+
+        await queue.put(item1)
+        await queue.put(item2)
+
+        retrieved_item = await queue.get()
+        assert retrieved_item == item1
+        assert "group_a" in queue._locked
+
+    @pytest.mark.asyncio
+    async def test_locked_group_blocks_retrieval(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that locked groups cannot have items retrieved"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item1 = TestItem(group_id="group_a", value=1)
+        item2 = TestItem(group_id="group_a", value=2)
+        item3 = TestItem(group_id="group_b", value=3)
+
+        await queue.put(item1)
+        await queue.put(item2)
+        await queue.put(item3)
+
+        retrieved_item1 = await queue.get()
+        assert retrieved_item1 == item1
+        assert "group_a" in queue._locked
+
+        retrieved_item2 = await queue.get()
+        assert retrieved_item2 == item3
+        assert "group_b" in queue._locked
+        assert "group_a" in queue._locked
+
+    @pytest.mark.asyncio
+    async def test_commit_unlocks_group(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that commit() unlocks the group and allows next item retrieval"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item1 = TestItem(group_id="group_a", value=1)
+        item2 = TestItem(group_id="group_a", value=2)
+
+        await queue.put(item1)
+        await queue.put(item2)
+
+        retrieved_item1 = await queue.get()
+        assert retrieved_item1 == item1
+        assert "group_a" in queue._locked
+
+        await queue.commit()
+        assert "group_a" not in queue._locked
+
+        retrieved_item2 = await queue.get()
+        assert retrieved_item2 == item2
+        assert "group_a" in queue._locked
+
+    @pytest.mark.asyncio
+    async def test_multiple_groups_concurrent_processing(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that different groups can be processed concurrently"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item_a1 = TestItem(group_id="group_a", value=1)
+        item_a2 = TestItem(group_id="group_a", value=2)
+        item_b1 = TestItem(group_id="group_b", value=3)
+        item_c1 = TestItem(group_id="group_c", value=4)
+
+        await queue.put(item_a1)
+        await queue.put(item_b1)
+        await queue.put(item_c1)
+        await queue.put(item_a2)
+
+        retrieved_items = []
+        for _ in range(3):
+            item = await queue.get()
+            retrieved_items.append(item)
+
+        assert len(queue._locked) == 3
+        assert "group_a" in queue._locked
+        assert "group_b" in queue._locked
+        assert "group_c" in queue._locked
+
+        group_ids = [queue._extract_group_key(item) for item in retrieved_items]
+        assert set(group_ids) == {"group_a", "group_b", "group_c"}
+
+    @pytest.mark.asyncio
+    async def test_get_blocks_when_all_groups_locked(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that get() blocks when all available groups are locked"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item1 = TestItem(group_id="group_a", value=1)
+        item2 = TestItem(group_id="group_a", value=2)
+
+        await queue.put(item1)
+        await queue.put(item2)
+
+        await queue.get()
+        assert "group_a" in queue._locked
+
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(queue.get(), timeout=0.1)
+
+    @pytest.mark.asyncio
+    async def test_no_group_key_single_group_behavior(
+        self, queue_no_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test behavior when group_key is None (all items in same group)"""
+        queue: GroupQueue[TestItemNoGroup] = queue_no_group_key
+
+        item1 = TestItemNoGroup(value=1)
+        item2 = TestItemNoGroup(value=2)
+
+        await queue.put(item1)
+        await queue.put(item2)
+
+        retrieved_item1 = await queue.get()
+        assert retrieved_item1 == item1
+        assert None in queue._locked
+
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(queue.get(), timeout=0.1)
+
+        await queue.commit()
+        assert None not in queue._locked
+
+        retrieved_item2 = await queue.get()
+        assert retrieved_item2 == item2
+
+    @pytest.mark.asyncio
+    async def test_commit_without_get_is_safe(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that calling commit() without get() doesn't break anything"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        await queue.commit()
+        assert len(queue._locked) == 0
+
+    @pytest.mark.asyncio
+    async def test_multiple_commits_are_safe(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that multiple commits after a single get are safe"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item = TestItem(group_id="group_a", value=1)
+        await queue.put(item)
+
+        retrieved_item = await queue.get()
+        assert retrieved_item == item
+
+        await queue.commit()
+        assert "group_a" not in queue._locked
+
+        await queue.commit()
+        assert "group_a" not in queue._locked
+
+    @pytest.mark.asyncio
+    async def test_fifo_within_group(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that items within a group are processed in FIFO order"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        items = [TestItem(group_id="group_a", value=i) for i in range(5)]
+        for item in items:
+            await queue.put(item)
+
+        processed_items = []
+        for _ in range(5):
+            item = await queue.get()
+            processed_items.append(item)
+            await queue.commit()
+
+        assert processed_items == items
+
+    @pytest.mark.asyncio
+    async def test_lock_prevents_queue_cleanup(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that locked groups prevent queue cleanup until unlocked"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        item = TestItem(group_id="group_a", value=1)
+        await queue.put(item)
+
+        await queue.get()
+        assert "group_a" in queue._queues
+        assert "group_a" in queue._locked
+
+        await queue.commit()
+        assert "group_a" not in queue._queues
+        assert "group_a" not in queue._locked
+
+    @pytest.mark.asyncio
+    async def test_extract_group_key_missing_attribute(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that missing group key attribute raises ValueError"""
+        queue: GroupQueue[TestItemNoGroup] = queue_with_group_key
+
+        bad_item = TestItemNoGroup(value=1)
+
+        with pytest.raises(ValueError, match="lacks attribute 'group_id'"):
+            await queue.put(bad_item)
+
+    @pytest.mark.asyncio
+    async def test_size_excludes_current_item(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that size() excludes the currently processed item"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        items = [TestItem(group_id="group_a", value=i) for i in range(3)]
+        for item in items:
+            await queue.put(item)
+
+        assert await queue.size() == 3
+
+        await queue.get()
+        assert await queue.size() == 3
+
+        await queue.commit()
+        assert await queue.size() == 2
+
+    @pytest.mark.asyncio
+    async def test_multiple_workers_different_groups(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test multiple workers processing items from different groups concurrently"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+        processed_items = []
+
+        async def worker(worker_id: int, process_time: float = 0.1) -> Any:
+            """Simulate a worker that processes items"""
+            try:
+                item = await queue.get()
+                processed_items.append((worker_id, item))
+                await asyncio.sleep(process_time)
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        items = [
+            TestItem(group_id="group_a", value=1),
+            TestItem(group_id="group_b", value=2),
+            TestItem(group_id="group_c", value=3),
+            TestItem(group_id="group_d", value=4),
+        ]
+
+        for item in items:
+            await queue.put(item)
+
+        results = await asyncio.gather(
+            worker(1), worker(2), worker(3), worker(4), return_exceptions=True
+        )
+
+        assert len([r for r in results if isinstance(r, TestItem)]) == 4
+        assert len(processed_items) == 4
+
+        processed_values = {item.value for _, item in processed_items}
+        assert processed_values == {1, 2, 3, 4}
+
+        assert len(queue._locked) == 0
+
+    @pytest.mark.asyncio
+    async def test_multiple_workers_same_group_exclusivity(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that multiple workers cannot process items from same group concurrently"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+        processing_log = []
+
+        async def worker(worker_id: int, process_time: float = 0.2) -> Any:
+            """Worker that logs processing start and end times"""
+            try:
+                item = await queue.get()
+                start_time = asyncio.get_event_loop().time()
+                processing_log.append(("start", worker_id, item.value, start_time))
+
+                await asyncio.sleep(process_time)
+
+                end_time = asyncio.get_event_loop().time()
+                processing_log.append(("end", worker_id, item.value, end_time))
+
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        items = [TestItem(group_id="group_a", value=i) for i in range(4)]
+        for item in items:
+            await queue.put(item)
+
+        results = await asyncio.gather(
+            worker(1), worker(2), worker(3), worker(4), return_exceptions=True
+        )
+
+        assert len([r for r in results if isinstance(r, TestItem)]) == 4
+
+        start_times = {}
+        end_times = {}
+
+        for event, worker_id, value, timestamp in processing_log:
+            if event == "start":
+                start_times[value] = timestamp
+            else:
+                end_times[value] = timestamp
+
+        sorted_items = sorted(start_times.items(), key=lambda x: x[1])
+
+        for i in range(1, len(sorted_items)):
+            current_value = sorted_items[i][0]
+            previous_value = sorted_items[i - 1][0]
+
+            current_start = start_times[current_value]
+            previous_end = end_times[previous_value]
+
+            assert (
+                current_start >= previous_end - 0.01
+            ), f"Item {current_value} started before item {previous_value} finished"
+
+        assert len(queue._locked) == 0
+
+    @pytest.mark.asyncio
+    async def test_mixed_groups_with_multiple_workers(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test workers processing mixed groups - some concurrent, some sequential"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+        processing_events = []
+
+        async def worker(worker_id: int) -> Any:
+            """Worker that tracks processing events"""
+            try:
+                item = await queue.get()
+                group = queue._extract_group_key(item)
+
+                start_time = asyncio.get_event_loop().time()
+                processing_events.append(
+                    ("start", worker_id, group, item.value, start_time)
+                )
+
+                process_time = 0.1 if group == "fast_group" else 0.2
+                await asyncio.sleep(process_time)
+
+                end_time = asyncio.get_event_loop().time()
+                processing_events.append(
+                    ("end", worker_id, group, item.value, end_time)
+                )
+
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        items = [
+            TestItem(group_id="same_group", value=1),
+            TestItem(group_id="same_group", value=2),
+            TestItem(group_id="same_group", value=3),
+            TestItem(group_id="fast_group", value=4),
+            TestItem(group_id="other_group", value=5),
+            TestItem(group_id="another_group", value=6),
+        ]
+
+        for item in items:
+            await queue.put(item)
+
+        results = await asyncio.gather(
+            *[worker(i) for i in range(1, 7)], return_exceptions=True
+        )
+
+        successful_results = [r for r in results if isinstance(r, TestItem)]
+        assert len(successful_results) == 6
+
+        group_events: dict[Any, Any] = {}
+        for event in processing_events:
+            _, worker_id, group, value, timestamp = event
+            if group not in group_events:
+                group_events[group] = []
+            group_events[group].append(event)
+
+        same_group_events = sorted(group_events["same_group"], key=lambda x: x[4])
+        starts = [e for e in same_group_events if e[0] == "start"]
+        ends = [e for e in same_group_events if e[0] == "end"]
+
+        for i in range(1, len(starts)):
+            assert starts[i][4] >= ends[i - 1][4] - 0.01
+
+        assert len(queue._locked) == 0
+
+    @pytest.mark.asyncio
+    async def test_high_concurrency_stress_test(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Stress test with many workers and items"""
+        queue: GroupQueue[TestItem] = queue_with_group_key
+
+        async def worker(worker_id: int) -> Any:
+            """Simple worker"""
+            results = []
+            while True:
+                try:
+
+                    item = await asyncio.wait_for(queue.get(), timeout=1.0)
+                    results.append(item)
+
+                    await asyncio.sleep(0.01 + (worker_id % 3) * 0.01)
+
+                    await queue.commit()
+                except asyncio.TimeoutError:
+                    break
+                except Exception as e:
+                    print(f"Worker {worker_id} error: {e}")
+                    break
+            return results
+
+        num_groups = 5
+        items_per_group = 4
+
+        for group_id in range(num_groups):
+            for item_id in range(items_per_group):
+                item = TestItem(
+                    group_id=f"group_{group_id}", value=group_id * 100 + item_id
+                )
+                await queue.put(item)
+
+        num_workers = 10
+        results = await asyncio.gather(
+            *[worker(i) for i in range(num_workers)], return_exceptions=True
+        )
+
+        all_processed = []
+        for result in results:
+            if isinstance(result, list):
+                all_processed.extend(result)
+
+        assert len(all_processed) == num_groups * items_per_group
+
+        processed_values = [item.value for item in all_processed]
+        expected_values = [
+            g * 100 + i for g in range(num_groups) for i in range(items_per_group)
+        ]
+        assert sorted(processed_values) == sorted(expected_values)
+
+        assert len(queue._locked) == 0
+        assert await queue.size() == 0
+
+    @pytest.mark.asyncio
+    async def test_frozen_lock_timeout_recovery(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that frozen locks are released after timeout and processing can resume"""
+
+        queue: GroupQueue[TestItem] = GroupQueue(
+            group_key="group_id", name="test_queue", lock_timeout=0.3
+        )
+
+        processed_items = []
+
+        async def normal_worker(worker_id: int) -> Any:
+            """Worker that processes items normally"""
+            try:
+                item = await queue.get()
+                processed_items.append((worker_id, item))
+                await asyncio.sleep(0.1)
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        async def hanging_worker(worker_id: int) -> Any:
+            """Worker that gets item but never commits (simulates hung worker)"""
+            try:
+                item = await queue.get()
+                processed_items.append((worker_id, item))
+
+                await asyncio.sleep(1.0)
+
+                return f"Worker {worker_id} hung"
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        items = [TestItem(group_id="group_a", value=i) for i in range(3)]
+        for item in items:
+            await queue.put(item)
+
+        hanging_task = asyncio.create_task(hanging_worker(999))
+
+        await asyncio.sleep(0.1)
+
+        assert "group_a" in queue._locked
+
+        normal_task = asyncio.create_task(normal_worker(1))
+
+        await asyncio.sleep(0.2)
+        assert not normal_task.done()
+
+        await asyncio.sleep(0.4)
+
+        await asyncio.wait_for(normal_task, timeout=2.0)
+
+        normal_result = await normal_task
+        assert isinstance(normal_result, TestItem)
+
+        hanging_task.cancel()
+        try:
+            await hanging_task
+        except asyncio.CancelledError:
+            pass
+
+        assert len(queue._locked) <= 1
+
+        remaining_worker = asyncio.create_task(normal_worker(2))
+        remaining_result = await asyncio.wait_for(remaining_worker, timeout=1.0)
+        assert isinstance(remaining_result, TestItem)
+
+        await asyncio.sleep(0.1)
+
+        processed_values = {
+            item.value for _, item in processed_items if isinstance(item, TestItem)
+        }
+        assert len(processed_values) >= 2
+
+    @pytest.mark.asyncio
+    async def test_lock_timeout_doesnt_affect_normal_processing(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test that lock timeout doesn't interfere with normal fast processing"""
+
+        queue: GroupQueue[TestItem] = GroupQueue(
+            group_key="group_id", name="test_queue", lock_timeout=2.0
+        )
+
+        processed_items = []
+
+        async def fast_worker(worker_id: int) -> Any:
+            """Worker that processes quickly (well under timeout)"""
+            try:
+                item = await queue.get()
+                processed_items.append((worker_id, item))
+                await asyncio.sleep(0.1)
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        items = [TestItem(group_id="group_a", value=i) for i in range(5)]
+        for item in items:
+            await queue.put(item)
+
+        results = []
+        for i in range(5):
+            task = asyncio.create_task(fast_worker(i))
+            result = await asyncio.wait_for(task, timeout=1.0)
+            results.append(result)
+
+        assert len([r for r in results if isinstance(r, TestItem)]) == 5
+
+        processed_values = {item.value for _, item in processed_items}
+        assert processed_values == {0, 1, 2, 3, 4}
+
+        assert len(queue._locked) == 0
+
+    @pytest.mark.asyncio
+    async def test_multiple_frozen_locks_recovery(
+        self, queue_with_group_key: GroupQueue[Any]
+    ) -> None:
+        """Test recovery when multiple groups have frozen locks"""
+        queue: GroupQueue[TestItem] = GroupQueue(
+            group_key="group_id", name="test_queue", lock_timeout=0.3
+        )
+
+        async def hanging_worker(worker_id: int, group: str) -> Any:
+            """Worker that grabs item from specific group and hangs"""
+            try:
+
+                while True:
+                    item = await queue.get()
+                    if item.group_id == group:
+
+                        await asyncio.sleep(1.0)
+                        return f"Worker {worker_id} hung with {group}"
+                    else:
+
+                        await queue.commit()
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        async def recovery_worker(worker_id: int) -> Any:
+            """Worker that should be able to process after timeout"""
+            try:
+                item = await queue.get()
+                await asyncio.sleep(0.05)
+                await queue.commit()
+                return item
+            except Exception as e:
+                return f"Worker {worker_id} error: {e}"
+
+        for group in ["group_a", "group_b", "group_c"]:
+            for i in range(2):
+                await queue.put(TestItem(group_id=group, value=i))
+
+        hanging_tasks = [
+            asyncio.create_task(hanging_worker(i, f"group_{chr(97+i)}"))
+            for i in range(3)
+        ]
+
+        await asyncio.sleep(0.1)
+
+        assert len(queue._locked) == 3
+
+        recovery_tasks = [
+            asyncio.create_task(recovery_worker(100 + i)) for i in range(3)
+        ]
+
+        await asyncio.sleep(0.1)
+
+        for task in recovery_tasks:
+            assert not task.done()
+
+        await asyncio.sleep(0.4)
+
+        results = await asyncio.gather(*recovery_tasks, return_exceptions=True)
+
+        successful_results = [r for r in results if isinstance(r, TestItem)]
+        assert len(successful_results) == 3
+
+        for task in hanging_tasks:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        await asyncio.sleep(0.1)
+        assert len(queue._locked) == 0

{port_ocean-0.26.2.dist-info → port_ocean-0.27.0.dist-info}/METADATA

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

{port_ocean-0.26.2.dist-info → port_ocean-0.27.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-integrations/_infra/Dockerfile.Deb,sha256=RW-BC8NaVmw3ASF7a3XNsjFN3ZN5gTVxbFrOmhBXq30,2251
+integrations/_infra/Dockerfile.Deb,sha256=ovmwNBRNrblTW6K9ru2FNTiT9qDgI7_zY28O__VMW6I,2367
 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
@@ -70,7 +70,7 @@ port_ocean/clients/port/utils.py,sha256=osFyAjw7Y5Qf2uVSqC7_RTCQfijiL1zS74JJM0go
 port_ocean/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/config/base.py,sha256=x1gFbzujrxn7EJudRT81C6eN9WsYAb3vOHwcpcpX8Tc,6370
 port_ocean/config/dynamic.py,sha256=Lrk4JRGtR-0YKQ9DDGexX5NGFE7EJ6VoHya19YYhssM,2687
-port_ocean/config/settings.py,sha256=SaCophXTKj_MgJRw5vrIXaNds1NEfewt0jzPQ0ytM2o,7192
+port_ocean/config/settings.py,sha256=keRT2FJyzQ2G0LNlNP4mqYSwwTjbybL7Ire0oggwScw,7226
 port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -106,15 +106,16 @@ port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iE
 port_ocean/core/handlers/port_app_config/api.py,sha256=r_Th66NEw38IpRdnXZcRvI8ACfvxW_A6V62WLwjWXlQ,1044
 port_ocean/core/handlers/port_app_config/base.py,sha256=Sup4-X_a7JGa27rMy_OgqGIjFHMlKBpKevicaK3AeHU,2919
 port_ocean/core/handlers/port_app_config/models.py,sha256=pO7oI7GIYZ9c2ZxLu8EQ97U2IPqzsbJf3gRQxlizEjE,2933
-port_ocean/core/handlers/queue/__init__.py,sha256=1fICM0ZLATmmj6f7cdq_eV2kmw0_jy7y2INuLQIpzIE,121
-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/queue/__init__.py,sha256=yzgicE_jAR1wtljFKxgyG6j-HbLcG_Zze5qw1kkALUI,171
+port_ocean/core/handlers/queue/abstract_queue.py,sha256=SaivrYbqg8qsX6wtQlJZyxgcbdMD5B9NZG3byN9AvrI,782
+port_ocean/core/handlers/queue/group_queue.py,sha256=JvvJOwz9z_aI4CjPr7yQX-0rOgqLI5wMdxWk2x5x-34,4989
+port_ocean/core/handlers/queue/local_queue.py,sha256=Y6qabDbrQ8aOPTN6Ct3lnMU7JnT8O8iTpoxMoVt6lFs,643
 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=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=4u9Q_djZAzxgwGHlHBmVBG26svEigeSka6GajcETd20,12976
-port_ocean/core/handlers/webhook/webhook_event.py,sha256=9wHXLY6IGgjuqrwXXvZm_RbYEd-a9qIFNxWnGbfPv6o,3877
+port_ocean/core/handlers/webhook/processor_manager.py,sha256=0KRPD1ae-7w0na2AZY-rq9_gY0IaMv9LdwEh6y4_OiQ,13282
+port_ocean/core/handlers/webhook/webhook_event.py,sha256=o-REML80GxN7jKonO-vlRnycN_8NAymbykQSUjVp5FI,3947
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=dUhytVM9uUbcDRzG1QWyvBvEJOWZY0dPVV3hXuukOfg,3587
 port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4_RgZnwSRmTCreKcBVM,220
@@ -172,6 +173,7 @@ port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=6yUsYooBYchiZP_
 port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=-Jd2rUG63fZM8LuyKtCp1tt4WEqO2m5woESjs1c91sU,44428
 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_group_queue.py,sha256=Y1BrQi5xwhk5bYDlKRWw9PenF5cqxIF2TIU_hldqji0,22801
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
 port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=zKwHhPAYEZoZ5Z2UETp1t--mbkS8uyvlXThB0obZTTc,3340
 port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=rqNFc-S_ZnPyDTSFTdiGcRFKbeDGfWQCH_f2UPbfcAA,52310
@@ -203,8 +205,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.26.2.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.26.2.dist-info/METADATA,sha256=vKDMPtrSkiVpDBs1OdmO3RdRYqp88fLfKuQdXPL_no0,6887
-port_ocean-0.26.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.26.2.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.26.2.dist-info/RECORD,,
+port_ocean-0.27.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.27.0.dist-info/METADATA,sha256=dWJb3IOgu_hp6Q1I5G4VxB3b31owoTzF7xSSgSpsGAM,6887
+port_ocean-0.27.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.27.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.27.0.dist-info/RECORD,,