port-ocean 0.1.3rc3__tar.gz → 0.1.4.dev1__tar.gz

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.1.3rc3
+Version: 0.1.4.dev1
 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.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/cli/commands/new.py

@@ -3,6 +3,7 @@
 import click
 from cookiecutter.main import cookiecutter  # type: ignore
 
+from port_ocean import __version__
 from port_ocean.cli.commands.main import cli_start, print_logo, console
 from port_ocean.cli.utils import cli_root_path
 
@@ -21,7 +22,11 @@ def new(path: str) -> None:
         "🚢 Unloading cargo... Setting up your integration at the dock.", style="bold"
     )
 
-    result = cookiecutter(f"{cli_root_path}/cookiecutter", output_dir=path)
+    result = cookiecutter(
+        f"{cli_root_path}/cookiecutter",
+        output_dir=path,
+        extra_context={"version": __version__},
+    )
     name = result.split("/")[-1]
 
     console.print(

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["{{cookiecutter.full_name}} <{{cookiecutter.email}}>"]
 
 [tool.poetry.dependencies]
 python = "^3.11"
-port_ocean = { version = "^0.1.0", extras = ["cli"] }
+port_ocean = { version = "^{{ cookiecutter.version }}", extras = ["cli"] }
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2"

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/config/base.py

@@ -8,7 +8,7 @@ from humps import decamelize
 from pydantic import BaseSettings
 from pydantic.env_settings import EnvSettingsSource, InitSettingsSource
 
-PROVIDER_WRAPPER_PATTERN = r"\\{\\{ from (.*) \\}\\}"
+PROVIDER_WRAPPER_PATTERN = r"{{ from (.*) }}"
 PROVIDER_CONFIG_PATTERN = r"^[a-zA-Z0-9]+ .*$"
 
 

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/config/dynamic.py

@@ -14,9 +14,10 @@ class Configuration(BaseModel, extra=Extra.allow):
 
 
 def dynamic_parse(value: Any, field: ModelField) -> Any:
-    if isinstance(value, str) and (
-        issubclass(field.annotation, dict) or issubclass(field.annotation, list)
-    ):
+    should_json_load = issubclass(field.annotation, dict) or issubclass(
+        field.annotation, list
+    )
+    if isinstance(value, str) and should_json_load:
         try:
             return json.loads(value)
         except json.JSONDecodeError:

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/event_listener/base.py

@@ -5,6 +5,9 @@ from pydantic import BaseModel, Extra
 
 
 class EventListenerEvents(TypedDict):
+    """
+    A dictionary containing event types and their corresponding event handlers.
+    """
     on_resync: Callable[[dict[Any, Any]], Awaitable[None]]
 
 
@@ -24,4 +27,8 @@ class EventListenerSettings(BaseModel, extra=Extra.allow):
     type: str
 
     def to_request(self) -> dict[str, Any]:
+        """
+        Converts the Settings object to a dictionary representation (request format).
+        This method is used when configuring the event listener settings for the Polling event listener.
+        """
         return {"type": self.type}

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/event_listener/factory.py

@@ -20,6 +20,16 @@ from port_ocean.exceptions.core import UnsupportedEventListenerTypeException
 
 
 class EventListenerFactory(BaseWithContext):
+    """
+    This class is responsible for creating different types of event listeners based on the provided configuration.
+    The factory takes a PortOceanContext, installation_id, and events dictionary as parameters.
+
+    Parameters:
+        context (PortOceanContext): The PortOceanContext object containing information about the current application context.
+        installation_id (str): The identifier of the installation associated with the event listener.
+        events (EventListenerEvents): A dictionary containing event types and their corresponding event handlers.
+
+    """
     def __init__(
         self,
         context: PortOceanContext,
@@ -31,6 +41,13 @@ class EventListenerFactory(BaseWithContext):
         self.events = events
 
     async def create_event_listener(self) -> BaseEventListener:
+        """
+        Creates and returns a specific event listener based on the provided configuration.
+        The event listener is wrapped with the events provided in the factory's initialization.
+        
+        Raises:
+            UnsupportedEventListenerTypeException: If the event listener type is not supported.
+        """
         wrapped_events: EventListenerEvents = {"on_resync": self.events["on_resync"]}
         event_listener: BaseEventListener
         config = self.context.config.event_listener

port_ocean-0.1.4.dev1/port_ocean/core/event_listener/http/event_listener.py

@@ -0,0 +1,66 @@
+from typing import Literal, Any
+
+from fastapi import APIRouter
+from loguru import logger
+from pydantic import AnyHttpUrl
+
+from port_ocean.context.ocean import ocean
+from port_ocean.core.event_listener.base import (
+    BaseEventListener,
+    EventListenerEvents,
+    EventListenerSettings,
+)
+
+
+class HttpEventListenerSettings(EventListenerSettings):
+    """
+    This class inherits from `EventListenerSettings`, which provides a foundation for defining event listener configurations.
+    The `HttpEventListenerSettings` specifically includes settings related to the HTTP event listener (Webhook).
+
+    Attributes:
+        type (Literal["WEBHOOK"]): A literal indicating the type of the event listener, which is set to "WEBHOOK" for this class.
+        app_host (AnyHttpUrl): The base URL of the application hosting the webhook.
+                               The "AnyHttpUrl" type indicates that the value must be a valid HTTP/HTTPS URL.
+    """
+    type: Literal["WEBHOOK"]
+    app_host: AnyHttpUrl
+
+    def to_request(self) -> dict[str, Any]:
+        return {
+            **super().to_request(),
+            "url": self.app_host + "/resync",
+        }
+
+
+class HttpEventListener(BaseEventListener):
+    """
+    HTTP event listener that listens for webhook events and triggers "on_resync" event.
+
+    This class inherits from `BaseEventListener`, which provides a foundation for creating event listeners.
+    The `HttpEventListener` listens for HTTP POST requests to the `/resync` endpoint and triggers the "on_resync" event.
+
+    Parameters:
+        events (EventListenerEvents): A dictionary containing event types and their corresponding event handlers.
+        event_listener_config (HttpEventListenerSettings): Configuration settings for the HTTP event listener.
+    """
+    def __init__(
+        self,
+        events: EventListenerEvents,
+        event_listener_config: HttpEventListenerSettings,
+    ):
+        super().__init__(events)
+        self.event_listener_config = event_listener_config
+
+    async def start(self) -> None:
+        """
+        Starts the HTTP event listener.
+        It sets up an APIRouter to handle the `/resync` endpoint and registers the "on_resync" event handler.
+        """
+        logger.info("Setting up HTTP Event Listener")
+        target_channel_router = APIRouter()
+
+        @target_channel_router.post("/resync")
+        async def resync() -> None:
+            await self.events["on_resync"]({})
+
+        ocean.app.fast_api_app.include_router(target_channel_router)

port_ocean-0.1.4.dev1/port_ocean/core/event_listener/kafka/event_listener.py

@@ -0,0 +1,141 @@
+import threading
+from typing import Any, Callable, Literal
+
+from loguru import logger
+
+from port_ocean.consumers.kafka_consumer import KafkaConsumer, KafkaConsumerConfig
+from port_ocean.context.ocean import (
+    PortOceanContext,
+    initialize_port_ocean_context,
+    ocean,
+)
+from port_ocean.core.event_listener.base import (
+    BaseEventListener,
+    EventListenerEvents,
+    EventListenerSettings,
+)
+
+
+class KafkaEventListenerSettings(EventListenerSettings):
+    """
+    This class inherits from `EventListenerSettings`, which provides a foundation for defining event listener configurations.
+    The `KafkaEventListenerSettings` specifically includes settings related to the Kafka event listener.
+
+    Attributes:
+        type (Literal["KAFKA"]): A literal indicating the type of the event listener, which is set to "KAFKA" for this class.
+        brokers (str): The comma-separated list of Kafka broker URLs to connect to.
+        security_protocol (str): The security protocol used for communication with Kafka brokers.
+                                 The default value is "SASL_SSL".
+        authentication_mechanism (str): The authentication mechanism used for secure access to Kafka brokers.
+                                        The default value is "SCRAM-SHA-512".
+        kafka_security_enabled (bool): A flag indicating whether Kafka security is enabled.
+                                       If True, credentials and security settings are used to connect to Kafka.
+                                       The default value is True.
+        consumer_poll_timeout (int): The maximum time in seconds to wait for messages during a poll.
+                                     The default value is 1 second.
+    """
+    type: Literal["KAFKA"]
+    brokers: str = "b-1-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196,b-2-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196,b-3-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196"
+    security_protocol: str = "SASL_SSL"
+    authentication_mechanism: str = "SCRAM-SHA-512"
+    kafka_security_enabled: bool = True
+    consumer_poll_timeout: int = 1
+
+
+class KafkaEventListener(BaseEventListener):
+    """
+    The `KafkaEventListener` specifically listens for messages from a Kafka consumer related to changes in an integration.
+
+    Parameters:
+        events (EventListenerEvents): A dictionary containing event types and their corresponding event handlers.
+        event_listener_config (KafkaEventListenerSettings): Configuration settings for the Kafka event listener.
+        org_id (str): The identifier of the organization associated with the integration.
+        integration_identifier (str): The identifier of the integration being monitored.
+        integration_type (str): The type of the integration being monitored.
+    """
+    def __init__(
+        self,
+        events: EventListenerEvents,
+        event_listener_config: KafkaEventListenerSettings,
+        org_id: str,
+        integration_identifier: str,
+        integration_type: str,
+    ):
+        super().__init__(events)
+        self.event_listener_config = event_listener_config
+        self.org_id = org_id
+        self.integration_identifier = integration_identifier
+        self.integration_type = integration_type
+
+    async def _get_kafka_config(self) -> KafkaConsumerConfig:
+        """
+        A private method that returns the Kafka consumer configuration based on the provided settings.
+        If Kafka security is enabled, it fetches Kafka credentials using the ocean.port_client.get_kafka_creds() method.
+        Otherwise, it returns the KafkaConsumerConfig object parsed from the event_listener_config.
+        """
+        if self.event_listener_config.kafka_security_enabled:
+            creds = await ocean.port_client.get_kafka_creds()
+            return KafkaConsumerConfig(
+                **self.event_listener_config.dict(),
+                username=creds.get("username"),
+                password=creds.get("password"),
+                group_name=f"{self.integration_type}.{self.integration_identifier}",
+            )
+
+        return KafkaConsumerConfig.parse_obj(self.event_listener_config.dict())
+
+    def _should_be_processed(self, msg_value: dict[Any, Any], topic: str) -> bool:
+        """
+        Determines if a given message should be processed based on the integration identifier and topic.
+        Returns True if the message should be processed, False otherwise.
+        """
+        integration_identifier = (
+            msg_value.get("diff", {}).get("after", {}).get("identifier")
+        )
+        if integration_identifier == self.integration_identifier and (
+            "change.log" in topic
+        ):
+            return msg_value.get("changelogDestination", {}).get("type", "") == "KAFKA"
+
+        return False
+
+    async def _handle_message(self, message: dict[Any, Any], topic: str) -> None:
+        """
+        A private method that handles incoming Kafka messages.
+        If the message should be processed (determined by `_should_be_processed`), it triggers the corresponding event handler.
+        """
+        if not self._should_be_processed(message, topic):
+            return
+
+        if "change.log" in topic and message is not None:
+            await self.events["on_resync"](message)
+
+    def _wrapped_start(
+        self, context: PortOceanContext, func: Callable[[], None]
+    ) -> Callable[[], None]:
+        """
+        A method that wraps the `start` method, initializing the PortOceanContext and invoking the given function.
+        """
+        ocean_app = context.app
+
+        def wrapper() -> None:
+            initialize_port_ocean_context(ocean_app=ocean_app)
+            func()
+
+        return wrapper
+
+    async def start(self) -> None:
+        """
+        The main method that starts the Kafka consumer.
+        It creates a KafkaConsumer instance with the given configuration and starts it in a separate thread.
+        """
+        consumer = KafkaConsumer(
+            msg_process=self._handle_message,
+            config=await self._get_kafka_config(),
+            org_id=self.org_id,
+        )
+        logger.info("Starting Kafka consumer")
+        threading.Thread(
+            name="ocean_kafka_consumer",
+            target=self._wrapped_start(ocean, consumer.start),
+        ).start()

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/event_listener/polling/event_listener.py

@@ -12,6 +12,14 @@ from port_ocean.core.event_listener.polling.utils import repeat_every
 
 
 class PollingEventListenerSettings(EventListenerSettings):
+    """
+    Attributes:
+        type (Literal["POLLING"]): A literal indicating the type of the event listener, which is set to "POLLING" for this class.
+        resync_on_start (bool): A flag indicating whether to trigger a resync event on the start of the polling event listener.
+                                If True, the "on_resync" event will be triggered immediately when the polling listener starts.
+        interval (int): The interval in seconds at which the polling event listener checks for changes in the integration.
+                        The default interval is set to 60 seconds.
+    """
     type: Literal["POLLING"]
     resync_on_start: bool = True
     interval: int = 60
@@ -21,6 +29,15 @@ class PollingEventListenerSettings(EventListenerSettings):
 
 
 class PollingEventListener(BaseEventListener):
+    """
+    Polling event listener that checks for changes in the integration every `interval` seconds.
+
+    The `PollingEventListener` periodically checks for changes in the integration and triggers the "on_resync" event if changes are detected.
+
+    Parameters:
+        events (EventListenerEvents): A dictionary containing event types and their corresponding event handlers.
+        event_listener_config (PollingEventListenerSettings): Configuration settings for the Polling event listener.
+    """
     def __init__(
         self,
         events: EventListenerEvents,
@@ -31,6 +48,11 @@ class PollingEventListener(BaseEventListener):
         self._last_updated_at = None
 
     async def start(self) -> None:
+        """
+        Starts the polling event listener.
+        It registers the "on_resync" event to be called every `interval` seconds specified in the `event_listener_config`.
+        The `on_resync` event is triggered if the integration has changed since the last update.
+        """
         logger.info(
             f"Setting up Polling event listener with interval: {self.event_listener_config.interval}"
         )

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections import defaultdict
 from itertools import groupby
 
 from port_ocean.clients.port.client import PortClient
@@ -33,12 +34,18 @@ async def get_related_entities(
         for entity in entities_with_relations
     ]
 
-    related_entities = []
+    blueprints_to_relations = defaultdict(list)
     for entity, blueprint in entity_to_blueprint:
         for relation_name, relation in entity.relations.items():
             relation_blueprint = blueprint.relations[relation_name].target
-            related_entities.append(
-                Entity(identifier=relation, blueprint=relation_blueprint)
+            blueprints_to_relations[relation_blueprint].extend(
+                relation if isinstance(relation, list) else [relation]
             )
 
-    return related_entities
+    return [
+        Entity(identifier=relation, blueprint=blueprint)
+        for blueprint, relations in blueprints_to_relations.items()
+        # multiple entities can point to the same relation in the same blueprint, for performance reasons
+        # we want to avoid fetching the same relation multiple times
+        for relation in set(relations)
+    ]

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/integrations/base.py

@@ -15,6 +15,29 @@ from port_ocean.exceptions.core import IntegrationAlreadyStartedException
 
 
 class BaseIntegration(SyncRawMixin, SyncMixin):
+    """
+    This is the default integration class that Ocean initializes when no custom integration class is
+    provided.
+
+    This class provides a foundation for implementing various integration types. It inherits from
+    both SyncRawMixin and SyncMixin, which provide synchronization and event handling functionality.
+
+    Parameters:
+        context (PortOceanContext): The PortOceanContext object providing the necessary context
+            for the integration.
+
+    Attributes:
+        started (bool): Flag indicating whether the integration has been started.
+        context (PortOceanContext): The PortOceanContext object containing integration context.
+        event_listener_factory (EventListenerFactory): Factory to create event listeners for
+            handling integration events.
+
+    Raises:
+        IntegrationAlreadyStartedException: Raised if the integration is attempted to be started
+            more than once.
+        NotImplementedError: Raised if the `on_resync` method is not implemented, and the event
+            strategy does not have a custom implementation for resync events.
+    """
     def __init__(self, context: PortOceanContext):
         SyncRawMixin.__init__(self)
         SyncMixin.__init__(self)
@@ -27,6 +50,9 @@ class BaseIntegration(SyncRawMixin, SyncMixin):
         )
 
     async def start(self) -> None:
+        """
+        Initializes handlers, establishes integration at the specified port, and starts the event listener.
+        """
         logger.info("Starting integration")
         if self.started:
             raise IntegrationAlreadyStartedException("Integration already started")

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/integrations/mixins/utils.py

@@ -1,6 +1,7 @@
 from contextlib import contextmanager
 from typing import Awaitable, Generator, Callable
 
+from loguru import logger
 from port_ocean.core.ocean_types import (
     ASYNC_GENERATOR_RESYNC_TYPE,
     RAW_RESULT,
@@ -20,9 +21,9 @@ def resync_error_handling() -> Generator[None, None, None]:
     except StopAsyncIteration:
         raise
     except Exception as error:
-        raise OceanAbortException(
-            f"Failed to execute resync function, error: {error}"
-        ) from error
+        err_msg = f"Failed to execute resync function, error: {error}"
+        logger.exception(err_msg)
+        raise OceanAbortException(err_msg) from error
 
 
 async def resync_function_wrapper(

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/port_ocean/core/models.py

@@ -10,7 +10,7 @@ class Entity(BaseModel):
     identifier: str
     blueprint: str
     title: str | None
-    team: str | list[str] = []
+    team: str | None | list[str | None] = []
     properties: dict[str, Any] = {}
     relations: dict[str, Any] = {}
 
@@ -18,19 +18,7 @@ class Entity(BaseModel):
     def parse_obj(cls: Type["Model"], obj: dict[Any, Any]) -> "Model":
         obj["identifier"] = str(obj.get("identifier"))
         obj["blueprint"] = str(obj.get("blueprint"))
-        if obj.get("team"):
-            team = obj.get("team")
-            obj["team"] = (
-                [str(item) for item in team]
-                if isinstance(team, list)
-                else str(obj.get("team"))
-            )
-
-        for key, value in obj.get("relations", {}).items():
-            if isinstance(value, list):
-                obj["relations"][key] = [str(item) for item in value]
-            else:
-                obj["relations"][key] = str(value)
+
         return super(Entity, cls).parse_obj(obj)
 
 

port_ocean-0.1.4.dev1/port_ocean/logger_setup.py

@@ -0,0 +1,36 @@
+import sys
+
+import loguru
+from loguru import logger
+
+from port_ocean.config.settings import LogLevelType
+
+
+def setup_logger(level: LogLevelType) -> None:
+    logger_format = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+        "<level>{level: <8}</level> | "
+        "<level>{message}</level> | {extra}"
+    )
+
+    logger.remove()
+    logger.add(
+        sys.stdout,
+        level=level.upper(),
+        format=logger_format,
+        enqueue=True,  # process logs in background
+        diagnose=False,  # hide variable values in log backtrace
+    )
+    logger.configure(patcher=exception_deserializer)
+
+
+def exception_deserializer(record: "loguru.Record") -> None:
+    """
+    Workaround for when trying to log exception objects with loguru.
+    loguru doesn't able to deserialize `Exception` subclasses.
+    https://github.com/Delgan/loguru/issues/504#issuecomment-917365972
+    """
+    exception: loguru.RecordException | None = record["exception"]
+    if exception is not None:
+        fixed = Exception(str(exception.value))
+        record["exception"] = exception._replace(value=fixed)

{port_ocean-0.1.3rc3 → port_ocean-0.1.4.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.1.3rc3"
+version = "0.1.4dev1"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"

port_ocean-0.1.3rc3/port_ocean/core/event_listener/http/event_listener.py

@@ -1,43 +0,0 @@
-from typing import Literal, Any
-
-from fastapi import APIRouter
-from loguru import logger
-from pydantic import AnyHttpUrl
-
-from port_ocean.context.ocean import ocean
-from port_ocean.core.event_listener.base import (
-    BaseEventListener,
-    EventListenerEvents,
-    EventListenerSettings,
-)
-
-
-class HttpEventListenerSettings(EventListenerSettings):
-    type: Literal["WEBHOOK"]
-    app_host: AnyHttpUrl
-
-    def to_request(self) -> dict[str, Any]:
-        return {
-            **super().to_request(),
-            "url": self.app_host + "/resync",
-        }
-
-
-class HttpEventListener(BaseEventListener):
-    def __init__(
-        self,
-        events: EventListenerEvents,
-        event_listener_config: HttpEventListenerSettings,
-    ):
-        super().__init__(events)
-        self.event_listener_config = event_listener_config
-
-    async def start(self) -> None:
-        logger.info("Setting up HTTP Event Listener")
-        target_channel_router = APIRouter()
-
-        @target_channel_router.post("/resync")
-        async def resync() -> None:
-            await self.events["on_resync"]({})
-
-        ocean.app.fast_api_app.include_router(target_channel_router)

port_ocean-0.1.3rc3/port_ocean/core/event_listener/kafka/event_listener.py

@@ -1,94 +0,0 @@
-import threading
-from typing import Any, Callable, Literal
-
-from loguru import logger
-
-from port_ocean.consumers.kafka_consumer import KafkaConsumer, KafkaConsumerConfig
-from port_ocean.context.ocean import (
-    PortOceanContext,
-    initialize_port_ocean_context,
-    ocean,
-)
-from port_ocean.core.event_listener.base import (
-    BaseEventListener,
-    EventListenerEvents,
-    EventListenerSettings,
-)
-
-
-class KafkaEventListenerSettings(EventListenerSettings):
-    type: Literal["KAFKA"]
-    brokers: str = "b-1-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196,b-2-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196,b-3-public.publicclusterprod.t9rw6w.c1.kafka.eu-west-1.amazonaws.com:9196"
-    security_protocol: str = "SASL_SSL"
-    authentication_mechanism: str = "SCRAM-SHA-512"
-    kafka_security_enabled: bool = True
-    consumer_poll_timeout: int = 1
-
-
-class KafkaEventListener(BaseEventListener):
-    def __init__(
-        self,
-        events: EventListenerEvents,
-        event_listener_config: KafkaEventListenerSettings,
-        org_id: str,
-        integration_identifier: str,
-        integration_type: str,
-    ):
-        super().__init__(events)
-        self.event_listener_config = event_listener_config
-        self.org_id = org_id
-        self.integration_identifier = integration_identifier
-        self.integration_type = integration_type
-
-    async def _get_kafka_config(self) -> KafkaConsumerConfig:
-        if self.event_listener_config.kafka_security_enabled:
-            creds = await ocean.port_client.get_kafka_creds()
-            return KafkaConsumerConfig(
-                **self.event_listener_config.dict(),
-                username=creds.get("username"),
-                password=creds.get("password"),
-                group_name=f"{self.integration_type}.{self.integration_identifier}",
-            )
-
-        return KafkaConsumerConfig.parse_obj(self.event_listener_config.dict())
-
-    def should_be_processed(self, msg_value: dict[Any, Any], topic: str) -> bool:
-        integration_identifier = (
-            msg_value.get("diff", {}).get("after", {}).get("identifier")
-        )
-        if integration_identifier == self.integration_identifier and (
-            "change.log" in topic
-        ):
-            return msg_value.get("changelogDestination", {}).get("type", "") == "KAFKA"
-
-        return False
-
-    async def _handle_message(self, message: dict[Any, Any], topic: str) -> None:
-        if not self.should_be_processed(message, topic):
-            return
-
-        if "change.log" in topic and message is not None:
-            await self.events["on_resync"](message)
-
-    def wrapped_start(
-        self, context: PortOceanContext, func: Callable[[], None]
-    ) -> Callable[[], None]:
-        ocean_app = context.app
-
-        def wrapper() -> None:
-            initialize_port_ocean_context(ocean_app=ocean_app)
-            func()
-
-        return wrapper
-
-    async def start(self) -> None:
-        consumer = KafkaConsumer(
-            msg_process=self._handle_message,
-            config=await self._get_kafka_config(),
-            org_id=self.org_id,
-        )
-        logger.info("Starting Kafka consumer")
-        threading.Thread(
-            name="ocean_kafka_consumer",
-            target=self.wrapped_start(ocean, consumer.start),
-        ).start()

port_ocean-0.1.3rc3/port_ocean/logger_setup.py

@@ -1,22 +0,0 @@
-import sys
-
-from loguru import logger
-
-from port_ocean.config.settings import LogLevelType
-
-
-def setup_logger(level: LogLevelType) -> None:
-    logger_format = (
-        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
-        "<level>{level: <8}</level> | "
-        "<level>{message}</level> | {extra}"
-    )
-
-    logger.remove()
-    logger.add(
-        sys.stdout,
-        level=level.upper(),
-        format=logger_format,
-        enqueue=True,  # process logs in background
-        diagnose=False,  # hide variable values in log backtrace
-    )