atlan-application-sdk 0.1.1rc29__tar.gz → 0.1.1rc31__tar.gz

atlan_application_sdk-0.1.1rc31/.github/release_notes.md

@@ -0,0 +1,11 @@
+## v0.1.1rc31 (August 14, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc30...v0.1.1rc31
+
+### Features
+
+- support for app registration via events (#635) (by @Nishant Munjal in [330b585](https://github.com/atlanhq/application-sdk/commit/330b585))
+
+### Bug Fixes
+
+- error logs related to deployment secrets (#651) (by @Nishchith Shetty in [09f6e5c](https://github.com/atlanhq/application-sdk/commit/09f6e5c))

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## v0.1.1rc31 (August 14, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc30...v0.1.1rc31
+
+### Features
+
+- support for app registration via events (#635) (by @Nishant Munjal in [330b585](https://github.com/atlanhq/application-sdk/commit/330b585))
+
+### Bug Fixes
+
+- error logs related to deployment secrets (#651) (by @Nishchith Shetty in [09f6e5c](https://github.com/atlanhq/application-sdk/commit/09f6e5c))
+
+
+
+## v0.1.1rc30 (August 13, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc29...v0.1.1rc30
+
+### Bug Fixes
+
+- download_files_from_object_store with correct files list (#652) (by @Nishchith Shetty in [e2ed7bd](https://github.com/atlanhq/application-sdk/commit/e2ed7bd))
+
 ## v0.1.1rc29 (August 13, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc28...v0.1.1rc29

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc29
+Version: 0.1.1rc31
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/application/__init__.py

@@ -3,8 +3,8 @@ from typing import Any, Dict, List, Optional, Tuple, Type
 
 from application_sdk.activities import ActivitiesInterface
 from application_sdk.clients.utils import get_workflow_client
+from application_sdk.events.models import EventRegistration
 from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.eventstore import EventRegistration
 from application_sdk.server import ServerInterface
 from application_sdk.server.fastapi import APIServer, HttpWorkflowTrigger
 from application_sdk.server.fastapi.models import EventWorkflowTrigger

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/clients/temporal.py

@@ -1,10 +1,12 @@
 import asyncio
 import uuid
 from concurrent.futures import ThreadPoolExecutor
+from datetime import timedelta
 from typing import Any, Dict, Optional, Sequence, Type
 
 from temporalio import activity, workflow
 from temporalio.client import Client, WorkflowExecutionStatus, WorkflowFailureError
+from temporalio.common import RetryPolicy
 from temporalio.types import CallableType, ClassType
 from temporalio.worker import (
     ActivityInboundInterceptor,
@@ -33,17 +35,17 @@ from application_sdk.constants import (
     WORKFLOW_PORT,
     WORKFLOW_TLS_ENABLED_KEY,
 )
-from application_sdk.inputs.secretstore import SecretStoreInput
-from application_sdk.inputs.statestore import StateType
-from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.eventstore import (
+from application_sdk.events.models import (
     ApplicationEventNames,
     Event,
     EventMetadata,
-    EventStore,
     EventTypes,
     WorkflowStates,
 )
+from application_sdk.inputs.secretstore import SecretStoreInput
+from application_sdk.inputs.statestore import StateType
+from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.outputs.eventstore import EventStore
 from application_sdk.outputs.secretstore import SecretStoreOutput
 from application_sdk.outputs.statestore import StateStoreOutput
 from application_sdk.workflows import WorkflowInterface
@@ -55,11 +57,30 @@ TEMPORAL_NOT_FOUND_FAILURE = (
 )
 
 
+# Activity for publishing events (runs outside sandbox)
+@activity.defn
+async def publish_event(event_data: dict) -> None:
+    """Activity to publish events outside the workflow sandbox.
+
+    Args:
+        event_data (dict): Event data to publish containing event_type, event_name,
+                          metadata, and data fields.
+    """
+    try:
+        event = Event(**event_data)
+        await EventStore.publish_event(event)
+        activity.logger.info(f"Published event: {event_data.get('event_name','')}")
+    except Exception as e:
+        activity.logger.error(f"Failed to publish event: {e}")
+        raise
+
+
 class EventActivityInboundInterceptor(ActivityInboundInterceptor):
     """Interceptor for tracking activity execution events.
 
     This interceptor captures the start and end of activity executions,
     creating events that can be used for monitoring and tracking.
+    Activities run outside the sandbox so they can directly call EventStore.
     """
 
     async def execute_activity(self, input: ExecuteActivityInput) -> Any:
@@ -71,31 +92,28 @@ class EventActivityInboundInterceptor(ActivityInboundInterceptor):
         Returns:
             Any: The result of the activity execution.
         """
-        event = Event(
+        # Extract activity information for tracking
+
+        start_event = Event(
             event_type=EventTypes.APPLICATION_EVENT.value,
             event_name=ApplicationEventNames.ACTIVITY_START.value,
             data={},
         )
-        EventStore.publish_event(event)
+        await EventStore.publish_event(start_event)
 
         output = None
         try:
             output = await super().execute_activity(input)
-        except Exception as e:
+        except Exception:
+            raise
+        finally:
             end_event = Event(
                 event_type=EventTypes.APPLICATION_EVENT.value,
                 event_name=ApplicationEventNames.ACTIVITY_END.value,
                 data={},
             )
-            EventStore.publish_event(end_event)
-            raise e
+            await EventStore.publish_event(end_event)
 
-        end_event = Event(
-            event_type=EventTypes.APPLICATION_EVENT.value,
-            event_name=ApplicationEventNames.ACTIVITY_END.value,
-            data={},
-        )
-        EventStore.publish_event(end_event)
         return output
 
 
@@ -104,6 +122,7 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
 
     This interceptor captures the start and end of workflow executions,
     creating events that can be used for monitoring and tracking.
+    Uses activities to publish events to avoid sandbox restrictions.
     """
 
     async def execute_workflow(self, input: ExecuteWorkflowInput) -> Any:
@@ -115,47 +134,56 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
         Returns:
             Any: The result of the workflow execution.
         """
-        with workflow.unsafe.sandbox_unrestricted():
-            EventStore.publish_event(
-                Event(
-                    metadata=EventMetadata(workflow_state=WorkflowStates.RUNNING.value),
-                    event_type=EventTypes.APPLICATION_EVENT.value,
-                    event_name=ApplicationEventNames.WORKFLOW_START.value,
-                    data={},
-                )
+
+        # Publish workflow start event via activity
+        try:
+            await workflow.execute_activity(
+                publish_event,
+                {
+                    "metadata": EventMetadata(
+                        workflow_state=WorkflowStates.RUNNING.value
+                    ),
+                    "event_type": EventTypes.APPLICATION_EVENT.value,
+                    "event_name": ApplicationEventNames.WORKFLOW_START.value,
+                    "data": {},
+                },
+                schedule_to_close_timeout=timedelta(seconds=30),
+                retry_policy=RetryPolicy(maximum_attempts=3),
             )
+        except Exception as e:
+            workflow.logger.warning(f"Failed to publish workflow start event: {e}")
+            # Don't fail the workflow if event publishing fails
 
         output = None
+        workflow_state = WorkflowStates.FAILED.value  # Default to failed
+
         try:
             output = await super().execute_workflow(input)
-        except Exception as e:
-            with workflow.unsafe.sandbox_unrestricted():
-                EventStore.publish_event(
-                    Event(
-                        metadata=EventMetadata(
-                            workflow_state=WorkflowStates.FAILED.value
-                        ),
-                        event_type=EventTypes.APPLICATION_EVENT.value,
-                        event_name=ApplicationEventNames.WORKFLOW_END.value,
-                        data={},
-                    ),
+            workflow_state = (
+                WorkflowStates.COMPLETED.value
+            )  # Update to completed on success
+        except Exception:
+            workflow_state = WorkflowStates.FAILED.value  # Keep as failed
+            raise
+        finally:
+            # Always publish workflow end event
+            try:
+                await workflow.execute_activity(
+                    publish_event,
+                    {
+                        "metadata": EventMetadata(workflow_state=workflow_state),
+                        "event_type": EventTypes.APPLICATION_EVENT.value,
+                        "event_name": ApplicationEventNames.WORKFLOW_END.value,
+                        "data": {},
+                    },
+                    schedule_to_close_timeout=timedelta(seconds=30),
+                    retry_policy=RetryPolicy(maximum_attempts=3),
+                )
+            except Exception as publish_error:
+                workflow.logger.warning(
+                    f"Failed to publish workflow end event: {publish_error}"
                 )
-            raise e
 
-        with workflow.unsafe.sandbox_unrestricted():
-            EventStore.publish_event(
-                Event(
-                    metadata=EventMetadata(
-                        workflow_state=WorkflowStates.COMPLETED.value
-                    ),
-                    event_type=EventTypes.APPLICATION_EVENT.value,
-                    event_name=ApplicationEventNames.WORKFLOW_END.value,
-                    data={
-                        "workflow_id": workflow.info().workflow_id,
-                        "workflow_run_id": workflow.info().run_id,
-                    },
-                ),
-            )
         return output
 
 
@@ -513,11 +541,14 @@ class TemporalWorkflowClient(WorkflowClient):
                 f"Started token refresh loop with dynamic interval (initial: {self._token_refresh_interval}s)"
             )
 
+        # Add the publish_event to the activities list
+        extended_activities = list(activities) + [publish_event]
+
         return Worker(
             self.client,
             task_queue=self.worker_task_queue,
             workflows=workflow_classes,
-            activities=activities,
+            activities=extended_activities,  # Use extended activities list
             workflow_runner=SandboxedWorkflowRunner(
                 restrictions=SandboxRestrictions.default.with_passthrough_modules(
                     *passthrough_modules

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/constants.py

@@ -128,6 +128,11 @@ DEPLOYMENT_OBJECT_STORE_NAME = os.getenv("DEPLOYMENT_OBJECT_STORE_NAME", "object
 UPSTREAM_OBJECT_STORE_NAME = os.getenv("UPSTREAM_OBJECT_STORE_NAME", "objectstore")
 #: Name of the pubsub component in DAPR
 EVENT_STORE_NAME = os.getenv("EVENT_STORE_NAME", "eventstore")
+#: DAPR binding operation for creating resources
+DAPR_BINDING_OPERATION_CREATE = "create"
+#: Version of worker start events used in the application
+WORKER_START_EVENT_VERSION = "v1"
+
 #: Whether to enable Atlan storage upload
 ENABLE_ATLAN_UPLOAD = os.getenv("ENABLE_ATLAN_UPLOAD", "false").lower() == "true"
 # Dapr Client Configuration
@@ -135,6 +140,7 @@ ENABLE_ATLAN_UPLOAD = os.getenv("ENABLE_ATLAN_UPLOAD", "false").lower() == "true
 DAPR_MAX_GRPC_MESSAGE_LENGTH = int(
     os.getenv("DAPR_MAX_GRPC_MESSAGE_LENGTH", "104857600")
 )
+
 #: Name of the deployment secret store component in DAPR
 DEPLOYMENT_SECRET_STORE_NAME = os.getenv(
     "DEPLOYMENT_SECRET_STORE_NAME", "deployment-secret-store"

atlan_application_sdk-0.1.1rc31/application_sdk/events/__init__.py

@@ -0,0 +1,5 @@
+"""Events module for handling application events.
+
+This module provides classes and utilities for handling various types of events
+in the application, including workflow, activity, and worker events.
+"""

atlan_application_sdk-0.1.1rc31/application_sdk/events/models.py

@@ -0,0 +1,176 @@
+"""Base event classes and models.
+
+This module contains the base classes and models for all events in the application.
+"""
+
+from abc import ABC
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from application_sdk.constants import APPLICATION_NAME, WORKER_START_EVENT_VERSION
+
+
+class EventTypes(Enum):
+    """Enumeration of event types."""
+
+    APPLICATION_EVENT = "application_events"
+
+
+class ApplicationEventNames(Enum):
+    """Enumeration of application event names."""
+
+    WORKFLOW_END = "workflow_end"
+    WORKFLOW_START = "workflow_start"
+    ACTIVITY_START = "activity_start"
+    ACTIVITY_END = "activity_end"
+    WORKER_START = "worker_start"
+    WORKER_END = "worker_end"
+    APPLICATION_START = "application_start"
+    APPLICATION_END = "application_end"
+
+
+class WorkflowStates(Enum):
+    """Enumeration of workflow states."""
+
+    UNKNOWN = "unknown"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class EventMetadata(BaseModel):
+    """Metadata for events.
+
+    Attributes:
+        application_name: Name of the application the event belongs to.
+        created_timestamp: Timestamp when the event was created.
+        workflow_type: Type of the workflow.
+        workflow_id: ID of the workflow.
+        workflow_run_id: Run ID of the workflow.
+        workflow_state: State of the workflow.
+        activity_type: Type of the activity.
+        activity_id: ID of the activity.
+        attempt: Attempt number for the activity.
+        topic_name: Name of the topic for the event.
+    """
+
+    application_name: str = Field(init=True, default=APPLICATION_NAME)
+    created_timestamp: int = Field(init=True, default=0)
+
+    # Workflow information
+    workflow_type: str | None = Field(init=True, default=None)
+    workflow_id: str | None = Field(init=True, default=None)
+    workflow_run_id: str | None = Field(init=True, default=None)
+    workflow_state: str | None = Field(init=True, default=WorkflowStates.UNKNOWN.value)
+
+    # Activity information (Only when in an activity flow)
+    activity_type: str | None = Field(init=True, default=None)
+    activity_id: str | None = Field(init=True, default=None)
+    attempt: int | None = Field(init=True, default=None)
+
+    topic_name: str | None = Field(init=False, default=None)
+
+
+class EventFilter(BaseModel):
+    """Filter for events.
+
+    Attributes:
+        path: Path to filter on.
+        operator: Operator to use for filtering.
+        value: Value to filter by.
+    """
+
+    path: str
+    operator: str
+    value: str
+
+
+class Consumes(BaseModel):
+    """Model for event consumption configuration.
+
+    Attributes:
+        event_id: ID of the event.
+        event_type: Type of the event.
+        event_name: Name of the event.
+        version: Version of the event.
+        filters: List of filters to apply.
+    """
+
+    event_id: str = Field(alias="eventId")
+    event_type: str = Field(alias="eventType")
+    event_name: str = Field(alias="eventName")
+    version: str = Field()
+    filters: List[EventFilter] = Field(init=True, default=[])
+
+
+class EventRegistration(BaseModel):
+    """Model for event registration.
+
+    Attributes:
+        consumes: List of events to consume.
+        produces: List of events to produce.
+    """
+
+    consumes: List[Consumes] = Field(init=True, default=[])
+    produces: List[Dict[str, Any]] = Field(init=True, default=[])
+
+
+class Event(BaseModel, ABC):
+    """Base class for all events.
+
+    Attributes:
+        metadata: Metadata for the event.
+        event_type: Type of the event.
+        event_name: Name of the event.
+        data: Data payload of the event.
+    """
+
+    metadata: EventMetadata = Field(init=True, default_factory=EventMetadata)
+
+    event_type: str
+    event_name: str
+
+    data: Dict[str, Any]
+
+    def get_topic_name(self):
+        """Get the topic name for this event.
+
+        Returns:
+            str: The topic name.
+        """
+        return self.event_type
+
+    class Config:
+        extra = "allow"
+
+
+class WorkerStartEventData(BaseModel):
+    """Model for worker creation event data.
+
+    This model represents the data structure used when publishing worker creation events.
+    It contains information about the worker configuration and environment.
+
+    Attributes:
+        application_name: Name of the application the worker belongs to.
+        task_queue: Task queue name for the worker.
+        namespace: Temporal namespace for the worker.
+        host: Host address of the Temporal server.
+        port: Port number of the Temporal server.
+        connection_string: Connection string for the Temporal server.
+        max_concurrent_activities: Maximum number of concurrent activities.
+        workflow_count: Number of workflow classes registered.
+        activity_count: Number of activity functions registered.
+    """
+
+    version: str = WORKER_START_EVENT_VERSION
+    application_name: str
+    task_queue: str
+    namespace: str
+    host: str
+    port: str
+    connection_string: str
+    max_concurrent_activities: Optional[int]
+    workflow_count: int
+    activity_count: int

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/inputs/objectstore.py

@@ -79,25 +79,11 @@ class ObjectStoreInput:
         try:
             # List all files in the object store path
             relative_path = os.path.relpath(file_path, download_file_prefix)
-            metadata = {"fileName": relative_path}
+            file_list = cls.list_all_files(relative_path, object_store_name)
 
-            try:
-                # Assuming the object store binding supports a "list" operation
-                response_data = cls._invoke_dapr_binding(
-                    operation=cls.OBJECT_LIST_OPERATION, metadata=metadata
-                )
-                file_list = orjson.loads(response_data.decode("utf-8"))
-            except Exception as e:
-                logger.error(
-                    f"Error listing files in object store path {download_file_prefix}: {str(e)}"
-                )
-                raise e
-
-            if not file_list:
-                logger.info(
-                    f"No files found in object store path: {download_file_prefix}"
-                )
-                return
+            logger.info(
+                f"Found list of files: {file_list} from: {download_file_prefix}"
+            )
 
             # Download each file
             for relative_path in file_list:

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/inputs/secretstore.py

@@ -7,6 +7,7 @@ from typing import Any, Dict
 
 from dapr.clients import DaprClient
 
+from application_sdk.common.dapr_utils import is_component_registered
 from application_sdk.constants import (
     DEPLOYMENT_NAME,
     DEPLOYMENT_SECRET_PATH,
@@ -22,7 +23,21 @@ logger = get_logger(__name__)
 class SecretStoreInput:
     @classmethod
     def get_deployment_secret(cls) -> Dict[str, Any]:
-        """Get deployment config with caching."""
+        """Get deployment config from the deployment secret store.
+
+        Validates that the deployment secret store component is registered
+        before attempting to fetch secrets to prevent errors.
+
+        Returns:
+            Dict[str, Any]: Deployment configuration data, or empty dict if
+                          component is unavailable or fetch fails.
+        """
+        if not is_component_registered(DEPLOYMENT_SECRET_STORE_NAME):
+            logger.warning(
+                f"Deployment secret store component '{DEPLOYMENT_SECRET_STORE_NAME}' is not registered"
+            )
+            return {}
+
         try:
             return cls.get_secret(DEPLOYMENT_SECRET_PATH, DEPLOYMENT_SECRET_STORE_NAME)
         except Exception as e:

{atlan_application_sdk-0.1.1rc29 → atlan_application_sdk-0.1.1rc31}/application_sdk/observability/observability.py

@@ -16,6 +16,7 @@ from dapr.clients import DaprClient
 from pydantic import BaseModel
 
 from application_sdk.constants import (
+    DAPR_BINDING_OPERATION_CREATE,
     DEPLOYMENT_OBJECT_STORE_NAME,
     ENABLE_OBSERVABILITY_DAPR_SINK,
     LOG_FILE_NAME,
@@ -449,7 +450,7 @@ class AtlanObservability(Generic[T], ABC):
                     with DaprClient() as client:
                         client.invoke_binding(
                             binding_name=DEPLOYMENT_OBJECT_STORE_NAME,
-                            operation="create",
+                            operation=DAPR_BINDING_OPERATION_CREATE,
                             data=file_content,
                             binding_metadata=metadata,
                         )

atlan_application_sdk-0.1.1rc31/application_sdk/outputs/eventstore.py

@@ -0,0 +1,109 @@
+"""Event store module for handling application events.
+
+This module provides the EventStore class for publishing application events
+to a pub/sub system with automatic fallback to HTTP binding.
+"""
+
+import json
+from datetime import datetime
+
+from dapr import clients
+from temporalio import activity, workflow
+
+from application_sdk.clients.atlan_auth import AtlanAuthClient
+from application_sdk.common.dapr_utils import is_component_registered
+from application_sdk.constants import (
+    APPLICATION_NAME,
+    DAPR_BINDING_OPERATION_CREATE,
+    EVENT_STORE_NAME,
+)
+from application_sdk.events.models import Event, EventMetadata, WorkflowStates
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+activity.logger = logger
+
+
+class EventStore:
+    """Event store for publishing application events.
+
+    This class provides functionality to publish events to a pub/sub system.
+    """
+
+    @classmethod
+    def enrich_event_metadata(cls, event: Event):
+        """Enrich the event metadata with the workflow and activity information.
+
+        Args:
+            event (Event): Event data.
+        """
+        if not event.metadata:
+            event.metadata = EventMetadata()
+
+        event.metadata.application_name = APPLICATION_NAME
+        event.metadata.created_timestamp = int(datetime.now().timestamp())
+        event.metadata.topic_name = event.get_topic_name()
+
+        try:
+            workflow_info = workflow.info()
+            if workflow_info:
+                event.metadata.workflow_type = workflow_info.workflow_type
+                event.metadata.workflow_id = workflow_info.workflow_id
+                event.metadata.workflow_run_id = workflow_info.run_id
+        except Exception:
+            logger.debug("Not in workflow context, cannot set workflow metadata")
+
+        try:
+            activity_info = activity.info()
+            if activity_info:
+                event.metadata.activity_type = activity_info.activity_type
+                event.metadata.activity_id = activity_info.activity_id
+                event.metadata.attempt = activity_info.attempt
+                event.metadata.workflow_type = activity_info.workflow_type
+                event.metadata.workflow_id = activity_info.workflow_id
+                event.metadata.workflow_run_id = activity_info.workflow_run_id
+                event.metadata.workflow_state = WorkflowStates.RUNNING.value
+        except Exception:
+            logger.debug("Not in activity context, cannot set activity metadata")
+
+        return event
+
+    @classmethod
+    async def publish_event(cls, event: Event):
+        """Publish event with automatic fallback between pub/sub and HTTP binding.
+
+        Args:
+            event (Event): Event data to publish.
+        """
+        if not is_component_registered(EVENT_STORE_NAME):
+            logger.warning(
+                "Skipping event publish because event store component is not registered",
+            )
+            return
+        try:
+            event = cls.enrich_event_metadata(event)
+
+            payload = json.dumps(event.model_dump(mode="json"))
+
+            # Prepare binding metadata with auth token for HTTP bindings
+            binding_metadata = {"content-type": "application/json"}
+
+            # Add auth token - HTTP bindings will use it, others will ignore it
+            auth_client = AtlanAuthClient()
+            binding_metadata.update(await auth_client.get_authenticated_headers())
+
+            with clients.DaprClient() as client:
+                client.invoke_binding(
+                    binding_name=EVENT_STORE_NAME,
+                    operation=DAPR_BINDING_OPERATION_CREATE,
+                    data=payload,
+                    binding_metadata=binding_metadata,
+                )
+                logger.info(
+                    f"Published event via binding on topic: {event.get_topic_name()}"
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to publish event on topic {event.get_topic_name()}: {e}",
+                exc_info=True,
+            )