atlan-application-sdk 2.3.0__py3-none-any.whl → 2.3.2__py3-none-any.whl

application_sdk/activities/query_extraction/sql.py

@@ -13,6 +13,7 @@ from application_sdk.activities.common.utils import (
     get_workflow_id,
 )
 from application_sdk.clients.sql import BaseSQLClient
+from application_sdk.common.file_ops import SafeFileOps
 from application_sdk.constants import UPSTREAM_OBJECT_STORE_NAME
 from application_sdk.handlers import HandlerInterface
 from application_sdk.handlers.sql import BaseSQLHandler
@@ -412,7 +413,7 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
 
         # find the last marker from the parallel_markers
         last_marker = parallel_markers[-1]["end"]
-        with open(marker_file_path, "w") as f:
+        with SafeFileOps.open(marker_file_path, "w") as f:
             f.write(last_marker)
 
         logger.info(f"Last marker: {last_marker}")
@@ -453,10 +454,10 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
             )
 
             logger.info(f"Marker file downloaded to {marker_file_path}")
-            if not os.path.exists(marker_file_path):
+            if not SafeFileOps.exists(marker_file_path):
                 logger.warning(f"Marker file does not exist at {marker_file_path}")
                 return None
-            with open(marker_file_path, "r") as f:
+            with SafeFileOps.open(marker_file_path, "r") as f:
                 current_marker = f.read()
             logger.info(f"Current marker: {current_marker}")
             return int(current_marker)
@@ -519,8 +520,8 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
         # Write the results to a metadata file
         output_path = os.path.join(workflow_args["output_path"], "raw", "query")
         metadata_file_path = os.path.join(output_path, "metadata.json.ignore")
-        os.makedirs(os.path.dirname(metadata_file_path), exist_ok=True)
-        with open(metadata_file_path, "w") as f:
+        SafeFileOps.makedirs(os.path.dirname(metadata_file_path), exist_ok=True)
+        with SafeFileOps.open(metadata_file_path, "w") as f:
             f.write(json.dumps(parallel_markers))
 
         await ObjectStore.upload_file(

application_sdk/common/file_ops.py

@@ -0,0 +1,122 @@
+import os
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, List, Optional, Union
+
+from application_sdk.common.path import convert_to_extended_path
+
+
+class SafeFileOps:
+    """Safe file operations with Windows extended-length path support."""
+
+    @staticmethod
+    def rename(src: Union[str, Path], dst: Union[str, Path]) -> None:
+        """Safely rename a file or directory, supporting long paths on Windows."""
+        os.rename(convert_to_extended_path(src), convert_to_extended_path(dst))
+
+    @staticmethod
+    def remove(path: Union[str, Path]) -> None:
+        """Safely remove a file, supporting long paths on Windows."""
+        os.remove(convert_to_extended_path(path))
+
+    @staticmethod
+    def unlink(path: Union[str, Path], missing_ok: bool = False) -> None:
+        """Safely unlink a file, supporting long paths on Windows."""
+        try:
+            os.unlink(convert_to_extended_path(path))
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    @staticmethod
+    def makedirs(
+        name: Union[str, Path], mode: int = 0o777, exist_ok: bool = False
+    ) -> None:
+        """Safely create directories, supporting long paths on Windows."""
+        os.makedirs(convert_to_extended_path(name), mode=mode, exist_ok=exist_ok)
+
+    @staticmethod
+    def mkdir(path: Union[str, Path], mode: int = 0o777) -> None:
+        """Safely create a directory, supporting long paths on Windows."""
+        os.mkdir(convert_to_extended_path(path), mode=mode)
+
+    @staticmethod
+    def rmdir(path: Union[str, Path]) -> None:
+        """Safely remove a directory, supporting long paths on Windows."""
+        os.rmdir(convert_to_extended_path(path))
+
+    @staticmethod
+    def exists(path: Union[str, Path]) -> bool:
+        """Safely check if a path exists, supporting long paths on Windows."""
+        return os.path.exists(convert_to_extended_path(path))
+
+    @staticmethod
+    def isfile(path: Union[str, Path]) -> bool:
+        """Safely check if a path is a file, supporting long paths on Windows."""
+        return os.path.isfile(convert_to_extended_path(path))
+
+    @staticmethod
+    def isdir(path: Union[str, Path]) -> bool:
+        """Safely check if a path is a directory, supporting long paths on Windows."""
+        return os.path.isdir(convert_to_extended_path(path))
+
+    @staticmethod
+    def rmtree(
+        path: Union[str, Path],
+        ignore_errors: bool = False,
+        onerror: Optional[Any] = None,
+    ) -> None:
+        """Safely remove a directory tree, supporting long paths on Windows."""
+        shutil.rmtree(
+            convert_to_extended_path(path), ignore_errors=ignore_errors, onerror=onerror
+        )
+
+    @staticmethod
+    def copy(
+        src: Union[str, Path], dst: Union[str, Path], follow_symlinks: bool = True
+    ) -> Union[str, Path]:
+        """Safely copy a file, supporting long paths on Windows."""
+        return shutil.copy(
+            convert_to_extended_path(src),
+            convert_to_extended_path(dst),
+            follow_symlinks=follow_symlinks,
+        )
+
+    @staticmethod
+    def move(src: Union[str, Path], dst: Union[str, Path]) -> Union[str, Path]:
+        """Safely move a file or directory, supporting long paths on Windows."""
+        return shutil.move(convert_to_extended_path(src), convert_to_extended_path(dst))
+
+    @staticmethod
+    @contextmanager
+    def open(
+        file: Union[str, Path],
+        mode: str = "r",
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+        closefd: bool = True,
+        opener: Optional[Any] = None,
+    ):
+        """Safely open a file, supporting long paths on Windows."""
+        f = open(
+            convert_to_extended_path(file),
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            closefd=closefd,
+            opener=opener,
+        )
+        try:
+            yield f
+        finally:
+            f.close()
+
+    @staticmethod
+    def listdir(path: Union[str, Path]) -> List[str]:
+        """Safely list directory contents, supporting long paths on Windows."""
+        return os.listdir(convert_to_extended_path(path))

application_sdk/common/path.py

@@ -0,0 +1,38 @@
+import os
+import sys
+from pathlib import Path
+from typing import Union
+
+from application_sdk.constants import WINDOWS_EXTENDED_PATH_PREFIX
+
+
+def convert_to_extended_path(path: Union[str, Path]) -> str:
+    """
+    Robust conversion to Windows extended-length path ({WINDOWS_EXTENDED_PATH_PREFIX}).
+
+    On Windows, this prefixes the path with {WINDOWS_EXTENDED_PATH_PREFIX} to bypass the 260-character limit.
+    It ensures the path is absolute and uses backslashes.
+    On non-Windows platforms, it returns the path as a string.
+
+    Args:
+        path: The path to convert (str or Path object).
+
+    Returns:
+        Optional[str]: The converted path string, or None if input is empty.
+    """
+    if not path:
+        raise ValueError("Path cannot be empty")
+
+    path_str = str(path)
+
+    if sys.platform != "win32":
+        return path_str
+
+    if path_str.startswith(WINDOWS_EXTENDED_PATH_PREFIX):
+        return path_str
+
+    # Use os.path.abspath for better Windows reliability than Path.absolute()
+    # It also handles normalization of separators to backslashes
+    abs_path = os.path.abspath(path_str)
+
+    return f"{WINDOWS_EXTENDED_PATH_PREFIX}{abs_path}"

application_sdk/constants.py

@@ -42,6 +42,8 @@ APP_HOST = str(os.getenv("ATLAN_APP_HTTP_HOST", "0.0.0.0"))
 APP_PORT = int(os.getenv("ATLAN_APP_HTTP_PORT", "8000"))
 #: Tenant ID for multi-tenant applications
 APP_TENANT_ID = os.getenv("ATLAN_TENANT_ID", "default")
+# Domain Name of the tenant
+DOMAIN_NAME = os.getenv("ATLAN_DOMAIN_NAME", "atlan.com")
 #: Host address for the application's dashboard
 APP_DASHBOARD_HOST = str(os.getenv("ATLAN_APP_DASHBOARD_HOST", "localhost"))
 #: Port number for the application's dashboard
@@ -239,6 +241,24 @@ METRICS_CLEANUP_ENABLED = (
 )
 METRICS_RETENTION_DAYS = int(os.getenv("ATLAN_METRICS_RETENTION_DAYS", "30"))
 
+# Segment Configuration
+#: Segment API URL for sending events. Defaults to https://api.segment.io/v1/batch
+SEGMENT_API_URL = os.getenv("ATLAN_SEGMENT_API_URL", "https://api.segment.io/v1/batch")
+#: Segment write key for authentication
+SEGMENT_WRITE_KEY = os.getenv("ATLAN_SEGMENT_WRITE_KEY", "")
+#: Whether to enable Segment metrics export
+ENABLE_SEGMENT_METRICS = (
+    os.getenv("ATLAN_ENABLE_SEGMENT_METRICS", "false").lower() == "true"
+)
+#: Default user ID for Segment events
+SEGMENT_DEFAULT_USER_ID = "atlan.automation"
+#: Maximum batch size for Segment events
+SEGMENT_BATCH_SIZE = int(os.getenv("ATLAN_SEGMENT_BATCH_SIZE", "100"))
+#: Maximum time to wait before sending a batch (in seconds)
+SEGMENT_BATCH_TIMEOUT_SECONDS = float(
+    os.getenv("ATLAN_SEGMENT_BATCH_TIMEOUT_SECONDS", "10.0")
+)
+
 # Traces Configuration
 ENABLE_OTLP_TRACES = os.getenv("ATLAN_ENABLE_OTLP_TRACES", "false").lower() == "true"
 TRACES_BATCH_SIZE = int(os.getenv("ATLAN_TRACES_BATCH_SIZE", "100"))
@@ -287,6 +307,9 @@ LOCK_RETRY_INTERVAL_SECONDS = int(os.getenv("LOCK_RETRY_INTERVAL_SECONDS", "60")
 ENABLE_MCP = os.getenv("ENABLE_MCP", "false").lower() == "true"
 MCP_METADATA_KEY = "__atlan_application_sdk_mcp_metadata"
 
+#: Windows extended-length path prefix
+WINDOWS_EXTENDED_PATH_PREFIX = "\\\\?\\"
+
 
 class ApplicationMode(str, Enum):
     """Application execution mode.

application_sdk/interceptors/events.py

@@ -66,6 +66,8 @@ class EventActivityInboundInterceptor(ActivityInboundInterceptor):
         Returns:
             Any: The result of the activity execution.
         """
+        import time
+
         start_event = Event(
             event_type=EventTypes.APPLICATION_EVENT.value,
             event_name=ApplicationEventNames.ACTIVITY_START.value,
@@ -73,16 +75,18 @@ class EventActivityInboundInterceptor(ActivityInboundInterceptor):
         )
         await EventStore.publish_event(start_event)
 
+        start_time = time.time()
         output = None
         try:
             output = await super().execute_activity(input)
         except Exception:
             raise
         finally:
+            duration_ms = (time.time() - start_time) * 1000
             end_event = Event(
                 event_type=EventTypes.APPLICATION_EVENT.value,
                 event_name=ApplicationEventNames.ACTIVITY_END.value,
-                data={},
+                data={"duration_ms": round(duration_ms, 2)},
             )
             await EventStore.publish_event(end_event)
 
@@ -106,6 +110,8 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
         Returns:
             Any: The result of the workflow execution.
         """
+        # Record start time (use workflow.time() for deterministic time in workflows)
+        start_time = workflow.time()
 
         # Publish workflow start event via activity
         try:
@@ -138,7 +144,10 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
             workflow_state = WorkflowStates.FAILED.value  # Keep as failed
             raise
         finally:
-            # Always publish workflow end event
+            # Calculate duration in milliseconds
+            duration_ms = (workflow.time() - start_time) * 1000
+
+            # Always publish workflow end event with duration
             try:
                 await workflow.execute_activity(
                     publish_event,
@@ -146,7 +155,7 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
                         "metadata": EventMetadata(workflow_state=workflow_state),
                         "event_type": EventTypes.APPLICATION_EVENT.value,
                         "event_name": ApplicationEventNames.WORKFLOW_END.value,
-                        "data": {},
+                        "data": {"duration_ms": round(duration_ms, 2)},
                     },
                     schedule_to_close_timeout=timedelta(seconds=30),
                     retry_policy=RetryPolicy(maximum_attempts=3),

application_sdk/io/json.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Optional, Unio
 import orjson
 from temporalio import activity
 
+from application_sdk.common.file_ops import SafeFileOps
 from application_sdk.common.types import DataframeType
 from application_sdk.constants import DAPR_MAX_GRPC_MESSAGE_LENGTH
 from application_sdk.io.utils import (
@@ -322,7 +323,7 @@ class JsonFileWriter(Writer):
 
         if typename:
             self.path = os.path.join(self.path, typename)
-        os.makedirs(self.path, exist_ok=True)
+        SafeFileOps.makedirs(self.path, exist_ok=True)
 
         if self.chunk_start:
             self.chunk_count = self.chunk_start + self.chunk_count
@@ -395,7 +396,7 @@ class JsonFileWriter(Writer):
                     and self.total_record_count % self.chunk_size == 0
                 ):
                     output_file_name = f"{self.path}/{path_gen(self.chunk_count, self.chunk_part, self.start_marker, self.end_marker, extension=self.extension)}"
-                    if os.path.exists(output_file_name):
+                    if SafeFileOps.exists(output_file_name):
                         await self._upload_file(output_file_name)
                         self.chunk_part += 1
 
@@ -403,6 +404,13 @@ class JsonFileWriter(Writer):
             if self.current_buffer_size > 0:
                 await self._flush_daft_buffer(buffer, self.chunk_part)
 
+            # Upload the final file (matching pandas behavior)
+            if self.current_buffer_size_bytes > 0:
+                output_file_name = f"{self.path}/{path_gen(self.chunk_count, self.chunk_part, self.start_marker, self.end_marker, extension=self.extension)}"
+                if os.path.exists(output_file_name):
+                    await self._upload_file(output_file_name)
+                    self.chunk_part += 1
+
             # Record metrics for successful write
             self.metrics.record_metric(
                 name="json_write_records",
@@ -411,6 +419,11 @@ class JsonFileWriter(Writer):
                 labels={"type": "daft"},
                 description="Number of records written to JSON files from daft DataFrame",
             )
+
+            # Increment chunk_count and record partitions (matching pandas behavior)
+            if self.chunk_start is None:
+                self.chunk_count += 1
+            self.partitions.append(self.chunk_part)
         except Exception as e:
             # Record metrics for failed write
             self.metrics.record_metric(
@@ -430,7 +443,7 @@ class JsonFileWriter(Writer):
         and uploads the file to the object store.
         """
         output_file_name = f"{self.path}/{path_gen(self.chunk_count, chunk_part, self.start_marker, self.end_marker, extension=self.extension)}"
-        with open(output_file_name, "ab+") as f:
+        with SafeFileOps.open(output_file_name, "ab+") as f:
             f.writelines(buffer)
         buffer.clear()  # Clear the buffer
 
@@ -450,8 +463,8 @@ class JsonFileWriter(Writer):
 
         This method writes a chunk to a JSON file and uploads the file to the object store.
         """
-        mode = "w" if not os.path.exists(file_name) else "a"
-        with open(file_name, mode=mode) as f:
+        mode = "w" if not SafeFileOps.exists(file_name) else "a"
+        with SafeFileOps.open(file_name, mode=mode) as f:
             chunk.to_json(f, orient="records", lines=True)
 
     async def _finalize(self) -> None:
@@ -462,7 +475,7 @@ class JsonFileWriter(Writer):
         # Upload the final file if there's remaining buffered data
         if self.current_buffer_size_bytes > 0:
             output_file_name = f"{self.path}/{path_gen(self.chunk_count, self.chunk_part, self.start_marker, self.end_marker, extension=self.extension)}"
-            if os.path.exists(output_file_name):
+            if SafeFileOps.exists(output_file_name):
                 await self._upload_file(output_file_name)
                 self.chunk_part += 1
 

application_sdk/io/parquet.py

@@ -1,6 +1,5 @@
 import inspect
 import os
-import shutil
 from typing import (
     TYPE_CHECKING,
     AsyncGenerator,
@@ -15,6 +14,7 @@ from typing import (
 from temporalio import activity
 
 from application_sdk.activities.common.utils import get_object_store_prefix
+from application_sdk.common.file_ops import SafeFileOps
 from application_sdk.constants import (
     DAPR_MAX_GRPC_MESSAGE_LENGTH,
     ENABLE_ATLAN_UPLOAD,
@@ -494,7 +494,7 @@ class ParquetFileWriter(Writer):
         # Create output directory
         if self.typename:
             self.path = os.path.join(self.path, self.typename)
-        os.makedirs(self.path, exist_ok=True)
+        SafeFileOps.makedirs(self.path, exist_ok=True)
 
     async def _write_batched_dataframe(
         self,
@@ -729,7 +729,7 @@ class ParquetFileWriter(Writer):
         )
 
         # Create the directory
-        os.makedirs(self.current_temp_folder_path, exist_ok=True)
+        SafeFileOps.makedirs(self.current_temp_folder_path, exist_ok=True)
 
     async def _write_chunk_to_temp_folder(self, chunk: "pd.DataFrame"):
         """Write a chunk to the current temp folder."""
@@ -740,7 +740,7 @@ class ParquetFileWriter(Writer):
         existing_files = len(
             [
                 f
-                for f in os.listdir(self.current_temp_folder_path)
+                for f in SafeFileOps.listdir(self.current_temp_folder_path)
                 if f.endswith(self.extension)
             ]
         )
@@ -780,7 +780,7 @@ class ParquetFileWriter(Writer):
                             folder_index=self.chunk_count,
                             chunk_part=i,
                         )
-                        os.rename(file_path, consolidated_file_path)
+                        SafeFileOps.rename(file_path, consolidated_file_path)
 
                         # Upload consolidated file to object store
                         await ObjectStore.upload_file(
@@ -789,7 +789,7 @@ class ParquetFileWriter(Writer):
                         )
 
                 # Clean up temp consolidated dir
-                shutil.rmtree(temp_consolidated_dir, ignore_errors=True)
+                SafeFileOps.rmtree(temp_consolidated_dir, ignore_errors=True)
 
             # Update statistics
             self.chunk_count += 1
@@ -825,13 +825,15 @@ class ParquetFileWriter(Writer):
             # Clean up all temp folders
             for folder_index in self.temp_folders_created:
                 temp_folder = self._get_temp_folder_path(folder_index)
-                if os.path.exists(temp_folder):
-                    shutil.rmtree(temp_folder, ignore_errors=True)
+                if SafeFileOps.exists(temp_folder):
+                    SafeFileOps.rmtree(temp_folder, ignore_errors=True)
 
             # Clean up base temp directory if it exists and is empty
             temp_base_path = os.path.join(self.path, "temp_accumulation")
-            if os.path.exists(temp_base_path) and not os.listdir(temp_base_path):
-                os.rmdir(temp_base_path)
+            if SafeFileOps.exists(temp_base_path) and not SafeFileOps.listdir(
+                temp_base_path
+            ):
+                SafeFileOps.rmdir(temp_base_path)
 
             # Reset state
             self.temp_folders_created.clear()

application_sdk/observability/logger_adaptor.py

@@ -168,9 +168,10 @@ logging.basicConfig(
     level=logging.getLevelNamesMapping()[LOG_LEVEL], handlers=[InterceptHandler()]
 )
 
-DEPENDENCY_LOGGERS = ["daft_io.stats", "tracing.span"]
+DEPENDENCY_LOGGERS = ["daft_io.stats", "tracing.span", "httpx"]
 
 # Configure external dependency loggers to reduce noise
+# Set httpx to WARNING to reduce verbose HTTP request logs (200 OK messages)
 for logger_name in DEPENDENCY_LOGGERS:
     logging.getLogger(logger_name).setLevel(logging.WARNING)
 

application_sdk/observability/metrics_adaptor.py

@@ -1,7 +1,7 @@
 import asyncio
+import atexit
 import logging
 import threading
-from enum import Enum
 from time import time
 from typing import Any, Dict, Optional
 
@@ -10,10 +10,10 @@ from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExp
 from opentelemetry.sdk.metrics import MeterProvider
 from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
 from opentelemetry.sdk.resources import Resource
-from pydantic import BaseModel
 
 from application_sdk.constants import (
     ENABLE_OTLP_METRICS,
+    ENABLE_SEGMENT_METRICS,
     METRICS_BATCH_SIZE,
     METRICS_CLEANUP_ENABLED,
     METRICS_FILE_NAME,
@@ -24,128 +24,37 @@ from application_sdk.constants import (
     OTEL_EXPORTER_TIMEOUT_SECONDS,
     OTEL_RESOURCE_ATTRIBUTES,
     OTEL_WF_NODE_NAME,
+    SEGMENT_API_URL,
+    SEGMENT_BATCH_SIZE,
+    SEGMENT_BATCH_TIMEOUT_SECONDS,
+    SEGMENT_DEFAULT_USER_ID,
+    SEGMENT_WRITE_KEY,
     SERVICE_NAME,
     SERVICE_VERSION,
 )
 from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.observability.models import MetricRecord, MetricType
 from application_sdk.observability.observability import AtlanObservability
+from application_sdk.observability.segment_client import SegmentClient
 from application_sdk.observability.utils import (
     get_observability_dir,
     get_workflow_context,
 )
 
-
-class MetricType(Enum):
-    """Enum for metric types."""
-
-    COUNTER = "counter"
-    GAUGE = "gauge"
-    HISTOGRAM = "histogram"
-
-
-class MetricRecord(BaseModel):
-    """A Pydantic model representing a metric record in the system.
-
-    This model defines the structure for metric data with fields for timestamp,
-    name, value, type, labels, and optional description and unit.
-
-    Attributes:
-        timestamp (float): Unix timestamp when the metric was recorded
-        name (str): Name of the metric
-        value (float): Numeric value of the metric
-        type (str): Type of metric (counter, gauge, or histogram)
-        labels (Dict[str, str]): Key-value pairs for metric dimensions
-        description (Optional[str]): Optional description of the metric
-        unit (Optional[str]): Optional unit of measurement
-    """
-
-    timestamp: float
-    name: str
-    value: float
-    type: MetricType  # counter, gauge, histogram
-    labels: Dict[str, str]
-    description: Optional[str] = None
-    unit: Optional[str] = None
-
-    class Config:
-        """Configuration for the MetricRecord Pydantic model.
-
-        Provides custom parsing logic to ensure consistent data types and structure
-        for metric records, including validation and type conversion for all fields.
-        """
-
-        @classmethod
-        def parse_obj(cls, obj):
-            if isinstance(obj, dict):
-                # Ensure labels is a dictionary with consistent structure
-                if "labels" in obj:
-                    # Create a new labels dict with only the expected fields
-                    new_labels = {}
-                    expected_fields = [
-                        "database",
-                        "status",
-                        "type",
-                        "mode",
-                        "workflow_id",
-                        "workflow_type",
-                    ]
-
-                    # Copy only the expected fields if they exist
-                    for field in expected_fields:
-                        if field in obj["labels"]:
-                            new_labels[field] = str(obj["labels"][field])
-
-                    obj["labels"] = new_labels
-
-                # Ensure value is float
-                if "value" in obj:
-                    try:
-                        obj["value"] = float(obj["value"])
-                    except (ValueError, TypeError):
-                        obj["value"] = 0.0
-
-                # Ensure timestamp is float
-                if "timestamp" in obj:
-                    try:
-                        obj["timestamp"] = float(obj["timestamp"])
-                    except (ValueError, TypeError):
-                        obj["timestamp"] = time()
-
-                # Ensure type is MetricType
-                if "type" in obj:
-                    try:
-                        obj["type"] = MetricType(obj["type"])
-                    except ValueError:
-                        obj["type"] = MetricType.COUNTER
-
-                # Ensure name is string
-                if "name" in obj:
-                    obj["name"] = str(obj["name"])
-
-                # Ensure description is string or None
-                if "description" in obj:
-                    obj["description"] = (
-                        str(obj["description"])
-                        if obj["description"] is not None
-                        else None
-                    )
-
-                # Ensure unit is string or None
-                if "unit" in obj:
-                    obj["unit"] = str(obj["unit"]) if obj["unit"] is not None else None
-
-            return super().parse_obj(obj)
+# MetricRecord and MetricType are imported from models.py to avoid circular dependencies
+logger = get_logger(__name__)
 
 
 class AtlanMetricsAdapter(AtlanObservability[MetricRecord]):
     """A metrics adapter for Atlan that extends AtlanObservability.
 
     This adapter provides functionality for recording, processing, and exporting
-    metrics to various backends including OpenTelemetry and parquet files.
+    metrics to various backends including OpenTelemetry, Segment API, and parquet files.
 
     Features:
     - Metric recording with labels and units
     - OpenTelemetry integration
+    - Segment API integration
     - Periodic metric flushing
     - Console logging
     - Parquet file storage
@@ -160,6 +69,7 @@ class AtlanMetricsAdapter(AtlanObservability[MetricRecord]):
         - Sets up base observability configuration
         - Configures date-based file settings
         - Initializes OpenTelemetry metrics if enabled
+        - Initializes Segment API client if enabled
         - Starts periodic flush task for metric buffering
         """
         super().__init__(
@@ -175,6 +85,18 @@ class AtlanMetricsAdapter(AtlanObservability[MetricRecord]):
         if ENABLE_OTLP_METRICS:
             self._setup_otel_metrics()
 
+        # Initialize Segment client (it handles enable/disable internally)
+        self.segment_client = SegmentClient(
+            enabled=ENABLE_SEGMENT_METRICS,
+            write_key=SEGMENT_WRITE_KEY,
+            api_url=SEGMENT_API_URL,
+            default_user_id=SEGMENT_DEFAULT_USER_ID,
+            batch_size=SEGMENT_BATCH_SIZE,
+            batch_timeout_seconds=SEGMENT_BATCH_TIMEOUT_SECONDS,
+        )
+        # Register cleanup handler to close SegmentClient on shutdown
+        atexit.register(self.segment_client.close)
+
         # Start periodic flush task if not already started
         if not AtlanMetricsAdapter._flush_task_started:
             try:
@@ -319,6 +241,7 @@ class AtlanMetricsAdapter(AtlanObservability[MetricRecord]):
         This method:
         - Validates the record is a MetricRecord
         - Sends to OpenTelemetry if enabled
+        - Sends to Segment API if enabled
         - Logs to console
         """
         if not isinstance(record, MetricRecord):
@@ -328,6 +251,9 @@ class AtlanMetricsAdapter(AtlanObservability[MetricRecord]):
         if ENABLE_OTLP_METRICS:
             self._send_to_otel(record)
 
+        # Send to Segment (client handles enable/disable internally)
+        self.segment_client.send_metric(record)
+
         # Log to console
         self._log_to_console(record)