bizon 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

bizon/engine/runner/adapters/thread.py

@@ -1,10 +1,12 @@
 import concurrent.futures
 import time
-import traceback
+from threading import Event
 
 from loguru import logger
 
 from bizon.common.models import BizonConfig
+from bizon.engine.pipeline.models import PipelineReturnStatus
+from bizon.engine.runner.config import RunnerStatus
 from bizon.engine.runner.runner import AbstractRunner
 
 
@@ -25,7 +27,7 @@ class ThreadRunner(AbstractRunner):
 
         return extra_kwargs
 
-    def run(self) -> bool:
+    def run(self) -> RunnerStatus:
         """Run the pipeline with dedicated threads for source and destination"""
 
         extra_kwargs = self.get_kwargs()
@@ -35,6 +37,10 @@ class ThreadRunner(AbstractRunner):
         result_producer = None
         result_consumer = None
 
+        # Start the producer and consumer events
+        producer_stop_event = Event()
+        consumer_stop_event = Event()
+
         extra_kwargs = self.get_kwargs()
 
         with concurrent.futures.ThreadPoolExecutor(
@@ -46,6 +52,7 @@ class ThreadRunner(AbstractRunner):
                 self.bizon_config,
                 self.config,
                 job.id,
+                producer_stop_event,
                 **extra_kwargs,
             )
             logger.info("Producer thread has started ...")
@@ -55,7 +62,9 @@ class ThreadRunner(AbstractRunner):
             future_consumer = executor.submit(
                 AbstractRunner.instanciate_and_run_consumer,
                 self.bizon_config,
+                self.config,
                 job.id,
+                consumer_stop_event,
                 **extra_kwargs,
             )
             logger.info("Consumer thread has started ...")
@@ -68,14 +77,28 @@ class ThreadRunner(AbstractRunner):
             self._is_running = False
 
             if not future_producer.running():
-                result_producer = future_producer.result()
+                result_producer: PipelineReturnStatus = future_producer.result()
                 logger.info(f"Producer thread stopped running with result: {result_producer}")
 
+                if result_producer.SUCCESS:
+                    logger.info("Producer thread has finished successfully, will wait for consumer to finish ...")
+                else:
+                    logger.error("Producer thread failed, stopping consumer ...")
+                    consumer_stop_event.set()
+
             if not future_consumer.running():
-                try:
-                    future_consumer.result()
-                except Exception as e:
-                    logger.error(f"Consumer thread stopped running with error {e}")
-                    logger.error(traceback.format_exc())
+                result_consumer = future_consumer.result()
+                logger.info(f"Consumer thread stopped running with result: {result_consumer}")
+
+                if result_consumer == PipelineReturnStatus.SUCCESS:
+                    logger.info("Consumer thread has finished successfully")
+                else:
+                    logger.error("Consumer thread failed, stopping producer ...")
+                    producer_stop_event.set()
+
+        runner_status = RunnerStatus(producer=future_producer.result(), consumer=future_consumer.result())
+
+        if not runner_status.is_success:
+            logger.error(runner_status.to_string())
 
-        return True
+        return runner_status

bizon/engine/runner/config.py

@@ -3,10 +3,13 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
+from bizon.engine.pipeline.models import PipelineReturnStatus
+
 
 class RunnerTypes(str, Enum):
     THREAD = "thread"
     PROCESS = "process"
+    STREAM = "stream"
 
 
 class LoggerLevel(str, Enum):
@@ -49,3 +52,28 @@ class RunnerConfig(BaseModel):
         description="Logging level",
         default=LoggerLevel.INFO,
     )
+
+
+class RunnerStatus(BaseModel):
+    producer: Optional[PipelineReturnStatus] = None
+    consumer: Optional[PipelineReturnStatus] = None
+    stream: Optional[PipelineReturnStatus] = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not ((self.producer is not None and self.consumer is not None) or self.stream is not None):
+            raise ValueError("Either both producer and consumer must be set, or stream must be set")
+
+    @property
+    def is_success(self):
+        if self.stream is not None:
+            return self.stream == PipelineReturnStatus.SUCCESS
+        return self.producer == PipelineReturnStatus.SUCCESS and self.consumer == PipelineReturnStatus.SUCCESS
+
+    def to_string(self):
+        if self.stream is not None:
+            return f"Pipeline finished with status {'Success' if self.is_success else 'Failure'} (Stream: {self.stream.value})"
+        return (
+            f"Pipeline finished with status {'Success' if self.is_success else 'Failure'} "
+            f"(Producer: {self.producer.value}, Consumer: {self.consumer.value})"
+        )

bizon/engine/runner/runner.py

@@ -1,18 +1,28 @@
+import multiprocessing
+import multiprocessing.synchronize
 import os
 import sys
+import threading
 from abc import ABC, abstractmethod
+from typing import Union
 
 from loguru import logger
 
+from bizon.alerting.models import AlertMethod
 from bizon.cli.utils import parse_from_yaml
 from bizon.common.models import BizonConfig, SyncMetadata
-from bizon.destinations.destination import AbstractDestination, DestinationFactory
+from bizon.destination.destination import AbstractDestination, DestinationFactory
 from bizon.engine.backend.backend import AbstractBackend, BackendFactory
 from bizon.engine.backend.models import JobStatus, StreamJob
 from bizon.engine.pipeline.producer import Producer
 from bizon.engine.queue.queue import AbstractQueue, QueueFactory
+from bizon.engine.runner.config import RunnerStatus
+from bizon.monitoring.monitor import AbstractMonitor, MonitorFactory
+from bizon.source.callback import AbstractSourceCallback
+from bizon.source.config import SourceSyncModes
 from bizon.source.discover import get_source_instance_by_source_and_stream
 from bizon.source.source import AbstractSource
+from bizon.transform.transform import Transform
 
 
 class AbstractRunner(ABC):
@@ -21,15 +31,31 @@ class AbstractRunner(ABC):
         # Internal state
         self._is_running: bool = False
 
-        # Attributes should be serializable for multiprocessing
-        self.config: dict = config
-        self.bizon_config = BizonConfig.model_validate(obj=config)
+        self.config = config
+        self.bizon_config = BizonConfig.model_validate(obj=self.config)
+
+        # Set pipeline information as environment variables
+        os.environ["BIZON_SYNC_NAME"] = self.bizon_config.name
+        os.environ["BIZON_SOURCE_NAME"] = self.bizon_config.source.name
+        os.environ["BIZON_SOURCE_STREAM"] = self.bizon_config.source.stream
+        os.environ["BIZON_DESTINATION_NAME"] = self.bizon_config.destination.name
 
         # Set log level
         logger.info(f"Setting log level to {self.bizon_config.engine.runner.log_level.name}")
         logger.remove()
         logger.add(sys.stderr, level=self.bizon_config.engine.runner.log_level)
 
+        if self.bizon_config.alerting:
+            logger.info(f"Setting up alerting method {self.bizon_config.alerting.type}")
+            if self.bizon_config.alerting.type == AlertMethod.SLACK:
+                from bizon.alerting.slack.handler import SlackHandler
+
+                alert = SlackHandler(
+                    config=self.bizon_config.alerting.config,
+                    log_levels=self.bizon_config.alerting.log_levels,
+                )
+            alert.add_handlers()
+
     @property
     def is_running(self) -> bool:
         """Return True if the pipeline is running"""
@@ -45,17 +71,23 @@ class AbstractRunner(ABC):
     def get_source(bizon_config: BizonConfig, config: dict) -> AbstractSource:
         """Get an instance of the source based on the source config dict"""
 
-        logger.info(f"Creating client for {bizon_config.source.source_name} - {bizon_config.source.stream_name} ...")
+        logger.info(f"Creating client for {bizon_config.source.name} - {bizon_config.source.stream} ...")
 
         # Get the client class, validate the config and return the client
         return get_source_instance_by_source_and_stream(
-            source_name=bizon_config.source.source_name,
-            stream_name=bizon_config.source.stream_name,
+            source_name=bizon_config.source.name,
+            stream_name=bizon_config.source.stream,
             source_config=config["source"],  # We pass the raw config to have flexibility for custom sources
         )
 
     @staticmethod
-    def get_destination(bizon_config: BizonConfig, backend: AbstractBackend, job_id: str) -> AbstractDestination:
+    def get_destination(
+        bizon_config: BizonConfig,
+        backend: AbstractBackend,
+        job_id: str,
+        source_callback: AbstractSourceCallback,
+        monitor: AbstractMonitor,
+    ) -> AbstractDestination:
         """Get an instance of the destination based on the destination config dict"""
 
         sync_metadata = SyncMetadata.from_bizon_config(job_id=job_id, config=bizon_config)
@@ -64,6 +96,8 @@ class AbstractRunner(ABC):
             sync_metadata=sync_metadata,
             config=bizon_config.destination,
             backend=backend,
+            source_callback=source_callback,
+            monitor=monitor,
         )
 
     @staticmethod
@@ -89,6 +123,16 @@ class AbstractRunner(ABC):
             **kwargs,
         )
 
+    @staticmethod
+    def get_transform(bizon_config: BizonConfig) -> Transform:
+        """Return the transform instance to apply to the source records"""
+        return Transform(transforms=bizon_config.transforms)
+
+    @staticmethod
+    def get_monitoring_client(sync_metadata: SyncMetadata, bizon_config: BizonConfig) -> AbstractMonitor:
+        """Return the monitoring client instance"""
+        return MonitorFactory.get_monitor(sync_metadata, bizon_config.monitoring)
+
     @staticmethod
     def get_or_create_job(
         bizon_config: BizonConfig,
@@ -101,15 +145,15 @@ class AbstractRunner(ABC):
         # Retrieve the last job for this stream
         job = backend.get_running_stream_job(
             name=bizon_config.name,
-            source_name=bizon_config.source.source_name,
-            stream_name=bizon_config.source.stream_name,
+            source_name=bizon_config.source.name,
+            stream_name=bizon_config.source.stream,
             session=session,
         )
 
         if job:
             # If force_create and a job is already running, we cancel it and create a new one
             if force_create:
-                logger.info(f"Found an existing job, cancelling it...")
+                logger.info("Found an existing job, cancelling it...")
                 backend.update_stream_job_status(job_id=job.id, job_status=JobStatus.CANCELED)
                 logger.info(f"Job {job.id} canceled. Creating a new one...")
             # Otherwise we return the existing job
@@ -119,13 +163,16 @@ class AbstractRunner(ABC):
 
         # If no job is running, we create a new one:
         # Get the total number of records
-        total_records = source.get_total_records_count()
+        if bizon_config.source.sync_mode == SourceSyncModes.STREAM:
+            total_records = None  # Not available for stream mode
+        else:
+            total_records = source.get_total_records_count()
 
         # Create a new job
         job = backend.create_stream_job(
             name=bizon_config.name,
-            source_name=bizon_config.source.source_name,
-            stream_name=bizon_config.source.stream_name,
+            source_name=bizon_config.source.name,
+            stream_name=bizon_config.source.stream,
             sync_mode=bizon_config.source.sync_mode,
             total_records_to_fetch=total_records,
             session=session,
@@ -148,9 +195,7 @@ class AbstractRunner(ABC):
         source = AbstractRunner.get_source(bizon_config=bizon_config, config=config)
 
         check_connection, connection_error = source.check_connection()
-        logger.info(
-            f"Connection to source {bizon_config.source.source_name} - {bizon_config.source.stream_name} successful"
-        )
+        logger.info(f"Connection to source {bizon_config.source.name} - {bizon_config.source.stream} successful")
 
         if not check_connection:
             logger.error(f"Error while connecting to source: {connection_error}")
@@ -170,12 +215,24 @@ class AbstractRunner(ABC):
         return job
 
     @staticmethod
-    def instanciate_and_run_producer(bizon_config: BizonConfig, config: dict, job_id: str, **kwargs):
+    def instanciate_and_run_producer(
+        bizon_config: BizonConfig,
+        config: dict,
+        job_id: str,
+        stop_event: Union[multiprocessing.synchronize.Event, threading.Event],
+        **kwargs,
+    ):
 
+        # Get the source instance
         source = AbstractRunner.get_source(bizon_config=bizon_config, config=config)
+
+        # Get the queue instance
         queue = AbstractRunner.get_queue(bizon_config=bizon_config, **kwargs)
+
+        # Get the backend instance
         backend = AbstractRunner.get_backend(bizon_config=bizon_config, **kwargs)
 
+        # Create the producer instance
         producer = AbstractRunner.get_producer(
             bizon_config=bizon_config,
             source=source,
@@ -183,22 +240,54 @@ class AbstractRunner(ABC):
             backend=backend,
         )
 
-        status = producer.run(job_id)
+        # Run the producer
+        status = producer.run(job_id, stop_event)
         return status
 
     @staticmethod
-    def instanciate_and_run_consumer(bizon_config: BizonConfig, job_id: str, **kwargs):
+    def instanciate_and_run_consumer(
+        bizon_config: BizonConfig,
+        config: dict,
+        job_id: str,
+        stop_event: Union[multiprocessing.synchronize.Event, threading.Event],
+        **kwargs,
+    ):
+        # Get the source callback instance
+        source_callback = AbstractRunner.get_source(
+            bizon_config=bizon_config, config=config
+        ).get_source_callback_instance()
 
+        sync_metadata = SyncMetadata.from_bizon_config(job_id=job_id, config=bizon_config)
+
+        # Get the queue instance
         queue = AbstractRunner.get_queue(bizon_config=bizon_config, **kwargs)
+
+        # Get the backend instance
         backend = AbstractRunner.get_backend(bizon_config=bizon_config, **kwargs)
-        destination = AbstractRunner.get_destination(bizon_config=bizon_config, backend=backend, job_id=job_id)
 
-        consumer = queue.get_consumer(destination=destination)
+        # Get the monitor instance
+        monitor = AbstractRunner.get_monitoring_client(sync_metadata=sync_metadata, bizon_config=bizon_config)
+
+        # Get the destination instance
+        destination = AbstractRunner.get_destination(
+            bizon_config=bizon_config, backend=backend, job_id=job_id, source_callback=source_callback, monitor=monitor
+        )
+
+        # Get the transform instance
+        transform = AbstractRunner.get_transform(bizon_config=bizon_config)
+
+        # Create the consumer instance
+        consumer = queue.get_consumer(
+            destination=destination,
+            transform=transform,
+            monitor=monitor,
+        )
 
-        status = consumer.run()
+        # Run the consumer
+        status = consumer.run(stop_event)
         return status
 
     @abstractmethod
-    def run(self) -> bool:
+    def run(self) -> RunnerStatus:
         """Run the pipeline with dedicated adapter for source and destination"""
         pass

bizon/monitoring/config.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from typing import Dict, Optional
+
+from pydantic import BaseModel, Field
+
+
+class MonitorType(str, Enum):
+    DATADOG = "datadog"
+
+
+class BaseMonitoringConfig(BaseModel):
+    enable_tracing: bool = Field(default=False, description="Enable tracing for the monitor")
+
+
+class DatadogConfig(BaseMonitoringConfig):
+    datadog_agent_host: Optional[str] = None
+    datadog_host_env_var: Optional[str] = None
+    datadog_agent_port: int = 8125
+    tags: Optional[Dict[str, str]] = Field(default={}, description="Key-value pairs to add to the monitor as tags")
+
+    @property
+    def host_is_configured(self) -> bool:
+        return bool(self.datadog_agent_host or self.datadog_host_env_var)
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.host_is_configured:
+            raise ValueError("Either datadog_agent_host or datadog_host_env_var must be specified")
+
+    class Config:
+        extra = "forbid"
+
+
+class MonitoringConfig(BaseMonitoringConfig):
+    type: MonitorType
+    config: Optional[DatadogConfig] = None
+
+    class Config:
+        extra = "forbid"

bizon/monitoring/datadog/monitor.py

@@ -0,0 +1,153 @@
+import os
+from contextlib import contextmanager
+from typing import Dict, List, Union
+
+from datadog import initialize, statsd
+from loguru import logger
+
+from bizon.common.models import SyncMetadata
+from bizon.engine.pipeline.models import PipelineReturnStatus
+from bizon.monitoring.config import MonitoringConfig
+from bizon.monitoring.monitor import AbstractMonitor
+from bizon.source.models import SourceRecord
+
+
+class DatadogMonitor(AbstractMonitor):
+    def __init__(self, sync_metadata: SyncMetadata, monitoring_config: MonitoringConfig):
+        super().__init__(sync_metadata, monitoring_config)
+
+        # In Kubernetes, set the host dynamically
+        try:
+            datadog_host_from_env_var = os.getenv(monitoring_config.config.datadog_host_env_var)
+            if datadog_host_from_env_var:
+                initialize(
+                    statsd_host=datadog_host_from_env_var,
+                    statsd_port=monitoring_config.config.datadog_agent_port,
+                )
+            else:
+                initialize(
+                    statsd_host=monitoring_config.config.datadog_agent_host,
+                    statsd_port=monitoring_config.config.datadog_agent_port,
+                )
+        except Exception as e:
+            logger.info(f"Failed to initialize Datadog agent: {e}")
+
+        self.pipeline_monitor_status = "bizon_pipeline.status"
+        self.tags = [
+            f"pipeline_name:{self.sync_metadata.name}",
+            f"pipeline_stream:{self.sync_metadata.stream_name}",
+            f"pipeline_source:{self.sync_metadata.source_name}",
+            f"pipeline_destination:{self.sync_metadata.destination_name}",
+        ] + [f"{key}:{value}" for key, value in self.monitoring_config.config.tags.items()]
+
+        self.pipeline_active_pipelines = "bizon_pipeline.active_pipelines"
+        self.pipeline_records_synced = "bizon_pipeline.records_synced"
+        self.pipeline_large_records = "bizon_pipeline.large_records"
+
+    def track_pipeline_status(self, pipeline_status: PipelineReturnStatus, extra_tags: Dict[str, str] = {}) -> None:
+        """
+        Track the status of the pipeline.
+
+        Args:
+            status (str): The current status of the pipeline (e.g., 'running', 'failed', 'completed').
+        """
+
+        statsd.increment(
+            self.pipeline_monitor_status,
+            tags=self.tags
+            + [f"pipeline_status:{pipeline_status}"]
+            + [f"{key}:{value}" for key, value in extra_tags.items()],
+        )
+
+    def track_records_synced(
+        self, num_records: int, destination_id: str, extra_tags: Dict[str, str] = {}, headers: List[Dict[str, str]] = []
+    ) -> Union[List[Dict[str, str]], None]:
+        """
+        Track the number of records synced in the pipeline.
+
+        Args:
+            num_records (int): Number of records synced in this batch
+        """
+        statsd.increment(
+            self.pipeline_records_synced,
+            value=num_records,
+            tags=self.tags + [f"{key}:{value}" for key, value in extra_tags.items()],
+        )
+        if os.getenv("DD_DATA_STREAMS_ENABLED") == "true":
+            from ddtrace.data_streams import set_produce_checkpoint
+
+            destination_type = self.sync_metadata.destination_alias
+
+            for header in headers:
+                if "x-datadog-sampling-priority" in header:
+                    del header["x-datadog-sampling-priority"]
+                if "dd-pathway-ctx-base64" in header:
+                    del header["dd-pathway-ctx-base64"]
+                set_produce_checkpoint(destination_type, destination_id, header.setdefault)
+            return headers
+
+    def track_large_records_synced(self, num_records: int, extra_tags: Dict[str, str] = {}) -> None:
+        statsd.increment(
+            self.pipeline_large_records,
+            value=num_records,
+            tags=self.tags + [f"{key}:{value}" for key, value in extra_tags.items()],
+        )
+
+    def track_source_iteration(self, records: List[SourceRecord]) -> Union[List[Dict[str, str]], None]:
+        """
+        Track the number of records consumed from a Kafka topic.
+
+        Args:
+            kafka_topic (str): The Kafka topic name
+        """
+
+        if os.getenv("DD_DATA_STREAMS_ENABLED") == "true":
+            from ddtrace.data_streams import set_consume_checkpoint
+
+            headers_list = []
+            for record in records:
+                headers = record.data.get("headers", {})
+                set_consume_checkpoint("kafka", record.data["topic"], headers.get)
+                headers_list.append(headers)
+            return headers_list
+
+    @contextmanager
+    def trace(self, operation_name: str, resource: str = None, extra_tags: Dict[str, str] = None):
+        """
+        Create a trace span for monitoring using Datadog APM.
+
+        Args:
+            operation_name (str): The name of the operation being traced
+            resource (str): The resource being operated on (e.g., topic name, table name)
+            extra_tags (Dict[str, str]): Additional tags for the trace
+
+        Yields:
+            A span object that can be used to add additional metadata
+        """
+        if not self.monitoring_config.config.enable_tracing:
+            yield None
+            return
+
+        try:
+            from ddtrace import tracer
+
+            # Combine tags
+            all_tags = self.tags.copy()
+            if extra_tags:
+                all_tags.extend([f"{key}:{value}" for key, value in extra_tags.items()])
+
+            # Create the span
+            with tracer.trace(operation_name, resource=resource) as span:
+                # Add tags to the span
+                for tag in all_tags:
+                    if ":" in tag:
+                        key, value = tag.split(":", 1)
+                        span.set_tag(key, value)
+                span.set_tag("_sampling_priority_v1", 1)
+                yield span
+        except ImportError:
+            logger.warning("ddtrace not available, skipping tracing")
+            yield None
+        except Exception as e:
+            logger.warning(f"Failed to create trace: {e}")
+            yield None

bizon/monitoring/monitor.py

@@ -0,0 +1,71 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Union
+
+from bizon.common.models import SyncMetadata
+from bizon.engine.pipeline.models import PipelineReturnStatus
+from bizon.monitoring.config import MonitoringConfig, MonitorType
+from bizon.source.models import SourceRecord
+
+
+class AbstractMonitor(ABC):
+    def __init__(self, sync_metadata: SyncMetadata, monitoring_config: MonitoringConfig):
+        self.sync_metadata = sync_metadata
+        self.monitoring_config = monitoring_config
+
+    @abstractmethod
+    def track_pipeline_status(self, pipeline_status: PipelineReturnStatus, extra_tags: Dict[str, str] = {}) -> None:
+        """
+        Track the status of the pipeline.
+
+        Args:
+            status (str): The current status of the pipeline (e.g., 'running', 'failed', 'completed').
+        """
+        pass
+
+    def track_source_iteration(self, records: List[SourceRecord], headers: Dict[str, str] = {}) -> None:
+        """
+        Run a process that tracks the source iteration.
+        """
+        pass
+
+    def track_records_synced(
+        self, num_records: int, destination_id: str, extra_tags: Dict[str, str] = {}, headers: Dict[str, str] = {}
+    ) -> None:
+        """
+        Track the number of records synced in the pipeline.
+        """
+        pass
+
+    def trace(self, operation_name: str, resource: str = None, extra_tags: Dict[str, str] = None):
+        """
+        Create a trace span for monitoring.
+
+        Args:
+            operation_name (str): The name of the operation being traced
+            resource (str): The resource being operated on (e.g., topic name, table name)
+            extra_tags (Dict[str, str]): Additional tags for the trace
+
+        Returns:
+            A context manager that can be used with 'with' statement
+        """
+        pass
+
+    def track_large_records_synced(self, num_records: int, extra_tags: Dict[str, str] = {}) -> None:
+        """
+        Track the number of large records synced in the destination system. This aims at helping to identify the source of the large records.
+        """
+        pass
+
+
+class MonitorFactory:
+    @staticmethod
+    def get_monitor(sync_metadata: SyncMetadata, monitoring_config: Union[MonitoringConfig, None]) -> AbstractMonitor:
+        if monitoring_config is None:
+            from bizon.monitoring.noop.monitor import NoOpMonitor
+
+            return NoOpMonitor(sync_metadata, monitoring_config)
+
+        if monitoring_config.type == MonitorType.DATADOG:
+            from bizon.monitoring.datadog.monitor import DatadogMonitor
+
+            return DatadogMonitor(sync_metadata, monitoring_config)

bizon/monitoring/noop/monitor.py

@@ -0,0 +1,30 @@
+from contextlib import contextmanager
+from typing import Dict
+
+from bizon.common.models import BizonConfig, SyncMetadata
+from bizon.engine.pipeline.models import PipelineReturnStatus
+from bizon.monitoring.config import MonitoringConfig
+from bizon.monitoring.monitor import AbstractMonitor
+
+
+class NoOpMonitor(AbstractMonitor):
+    def __init__(self, sync_metadata: SyncMetadata, monitoring_config: MonitoringConfig):
+        super().__init__(sync_metadata, monitoring_config)
+
+    def track_pipeline_status(self, pipeline_status: PipelineReturnStatus) -> None:
+        pass
+
+    @contextmanager
+    def trace(self, operation_name: str, resource: str = None, extra_tags: Dict[str, str] = None):
+        """
+        No-op trace implementation.
+
+        Args:
+            operation_name (str): The name of the operation being traced
+            resource (str): The resource being operated on (e.g., topic name, table name)
+            extra_tags (Dict[str, str]): Additional tags for the trace
+
+        Yields:
+            None (no-op implementation)
+        """
+        yield None