acryl-datahub 1.2.0.7rc3__py3-none-any.whl → 1.2.0.7rc4__py3-none-any.whl

datahub/ingestion/source/unity/proxy_patch.py

@@ -0,0 +1,321 @@
+"""
+Proxy authentication patch for databricks-sql < 3.0 compatibility.
+
+This module provides proxy authentication fixes for databricks-sql connector < 3.0
+to resolve "407 Proxy Authentication Required" errors that occur even when
+proxy environment variables are correctly set.
+
+The patch implements the same fix as Databricks PR #354:
+https://github.com/databricks/databricks-sql-python/pull/354
+"""
+
+import logging
+import os
+import urllib.parse
+from typing import Dict, Optional
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+PROXY_VARS = ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy"]
+
+
+def mask_proxy_credentials(url: Optional[str]) -> str:
+    """Mask credentials in proxy URL for safe logging."""
+    if not url:
+        return "None"
+
+    try:
+        parsed = urllib.parse.urlparse(url)
+        if parsed.username:
+            # Replace credentials with masked version
+            masked_netloc = parsed.netloc
+            if parsed.username and parsed.password:
+                masked_netloc = masked_netloc.replace(
+                    f"{parsed.username}:{parsed.password}@", f"{parsed.username}:***@"
+                )
+            elif parsed.username:
+                masked_netloc = masked_netloc.replace(
+                    f"{parsed.username}@", f"{parsed.username}:***@"
+                )
+
+            return urllib.parse.urlunparse(
+                (
+                    parsed.scheme,
+                    masked_netloc,
+                    parsed.path,
+                    parsed.params,
+                    parsed.query,
+                    parsed.fragment,
+                )
+            )
+        else:
+            return url
+    except Exception:
+        return "***INVALID_URL***"
+
+
+def _ensure_thrift_imports():
+    """Ensure required thrift imports are loaded before accessing thrift_http_client.
+
+    The databricks-sql thrift_http_client requires thrift.transport.THttpClient.THttpClient
+    to be accessible. This is achieved by importing the required modules in the right order.
+    """
+    try:
+        # Import thrift submodules - this makes them accessible as attributes
+        import thrift.transport.THttpClient  # noqa: F401 # Used to make thrift.transport accessible
+
+        logger.debug("Successfully imported required thrift modules")
+    except Exception as e:
+        logger.debug(f"Could not import thrift modules: {e}")
+        raise
+
+
+def _log_proxy_environment():
+    """Log detected proxy environment variables for debugging."""
+    proxy_env_vars = {}
+    for var in PROXY_VARS:
+        value = os.environ.get(var)
+        if value:
+            masked_value = mask_proxy_credentials(value)
+            proxy_env_vars[var] = masked_value
+
+    if proxy_env_vars:
+        logger.info(f"Detected proxy environment variables: {proxy_env_vars}")
+    else:
+        logger.debug("No proxy environment variables detected")
+
+
+def _basic_proxy_auth_header(proxy_url: str) -> Optional[Dict[str, str]]:
+    """Create proxy authentication header using the same method as Databricks >= 3.0.
+
+    Based on the basic_proxy_auth_header method from databricks-sql-connector >= 3.0:
+    https://github.com/databricks/databricks-sql-python/pull/354
+    """
+    try:
+        from urllib3.util import make_headers
+
+        parsed = urllib.parse.urlparse(proxy_url)
+        if parsed.username and parsed.password:
+            # Code reused from https://github.com/databricks/databricks-sql-python/pull/354
+            # URL decode the username and password (same as Databricks method)
+            username = urllib.parse.unquote(parsed.username)
+            password = urllib.parse.unquote(parsed.password)
+            auth_string = f"{username}:{password}"
+
+            # Create proxy URL without credentials
+            proxy_host_port = f"{parsed.scheme}://{parsed.hostname}"
+            if parsed.port:
+                proxy_host_port += f":{parsed.port}"
+
+            # Code reused from https://github.com/databricks/databricks-sql-python/pull/354
+            # Use make_headers like the newer Databricks version does
+            proxy_headers = make_headers(proxy_basic_auth=auth_string)
+
+            return {
+                "proxy_url": proxy_host_port,
+                "proxy_headers": proxy_headers,
+                "auth_string": auth_string,  # Keep for backward compatibility with tests
+            }
+    except Exception as e:
+        logger.debug(f"Failed to create proxy auth header from URL {proxy_url}: {e}")
+
+    return None
+
+
+def _handle_proxy_connection(self, original_open, pool_kwargs):
+    """Handle proxy connection setup with authentication headers."""
+    from urllib3.poolmanager import ProxyManager
+
+    logger.info(f"Using proxy for connection to {self.host}:{self.port}")
+    proxy_uri = getattr(self, "proxy_uri", None)
+    logger.debug(
+        f"Proxy URI: {mask_proxy_credentials(proxy_uri) if proxy_uri else 'None'}"
+    )
+
+    # Compute proxy authentication headers properly (the bug fix!)
+    proxy_headers = None
+    proxy_env_found = None
+    for env_var in ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"]:
+        proxy_url = os.environ.get(env_var)
+        if proxy_url:
+            logger.debug(
+                f"Found proxy URL in {env_var}: {mask_proxy_credentials(proxy_url)}"
+            )
+            auth_info = _basic_proxy_auth_header(proxy_url)
+            if auth_info:
+                proxy_headers = auth_info["proxy_headers"]
+                proxy_env_found = env_var
+                logger.debug(f"Successfully created proxy headers from {env_var}")
+                break
+            else:
+                logger.debug(
+                    f"No authentication info found in proxy URL from {env_var}"
+                )
+
+    if proxy_headers:
+        logger.info(f"Using proxy authentication headers from {proxy_env_found}")
+    else:
+        logger.warning(
+            "No proxy authentication headers could be created from environment variables"
+        )
+
+    proxy_manager = ProxyManager(
+        self.proxy_uri,
+        num_pools=1,
+        proxy_headers=proxy_headers,
+    )
+
+    # Validate proxy manager attributes
+    if not hasattr(self, "realhost") or not hasattr(self, "realport"):
+        logger.warning(
+            "THttpClient missing realhost/realport attributes, falling back to original"
+        )
+        return original_open(self)
+
+    # Set up the connection pool
+    self._THttpClient__pool = proxy_manager.connection_from_host(
+        host=self.realhost,
+        port=self.realport,
+        scheme=self.scheme,
+        pool_kwargs=pool_kwargs,  # type: ignore
+    )
+    logger.debug(f"Created proxy connection pool for {self.realhost}:{self.realport}")
+
+
+def _create_patched_open_method(original_open):
+    """Create the patched THttpClient.open method with proxy authentication fix."""
+
+    def patched_open(self):
+        """Patched version of THttpClient.open following databricks-sql >= 3.0 structure.
+
+        This is largely copied from the >= 3.0 implementation:
+        https://github.com/databricks/databricks-sql-python/pull/354/files
+        """
+        logger.debug(
+            f"Patched THttpClient.open called for host={getattr(self, 'host', 'unknown')}, scheme={getattr(self, 'scheme', 'unknown')}"
+        )
+
+        try:
+            # Validate required attributes
+            required_attrs = ["scheme", "host", "port", "max_connections"]
+            missing_attrs = [attr for attr in required_attrs if not hasattr(self, attr)]
+            if missing_attrs:
+                logger.warning(
+                    f"THttpClient missing required attributes: {missing_attrs}, falling back to original"
+                )
+                return original_open(self)
+
+            # Code structure reused from https://github.com/databricks/databricks-sql-python/pull/354
+            # Determine pool class based on scheme
+            if self.scheme == "http":
+                from urllib3 import HTTPConnectionPool
+
+                pool_class = HTTPConnectionPool
+            elif self.scheme == "https":
+                from urllib3 import HTTPSConnectionPool
+
+                pool_class = HTTPSConnectionPool
+            else:
+                logger.warning(
+                    f"Unknown scheme '{self.scheme}', falling back to original"
+                )
+                return original_open(self)
+
+            _pool_kwargs = {"maxsize": self.max_connections}
+            logger.debug(f"Pool kwargs: {_pool_kwargs}")
+
+            if self.using_proxy():
+                return _handle_proxy_connection(self, original_open, _pool_kwargs)
+            else:
+                logger.debug(f"Direct connection (no proxy) to {self.host}:{self.port}")
+                self._THttpClient__pool = pool_class(
+                    self.host, self.port, **_pool_kwargs
+                )
+
+            logger.debug("Patched THttpClient.open completed successfully")
+
+        except Exception as e:
+            logger.warning(
+                f"Error in proxy auth patch: {e}, falling back to original",
+                exc_info=True,
+            )
+            # Fallback to original implementation
+            try:
+                return original_open(self)
+            except Exception as fallback_error:
+                logger.error(
+                    f"Fallback to original THttpClient.open also failed: {fallback_error}",
+                    exc_info=True,
+                )
+                raise
+
+    return patched_open
+
+
+def apply_databricks_proxy_fix():
+    """Apply the databricks-sql < 3.0 proxy authentication fix at module import time.
+
+    This implements the same fix as Databricks PR #354 to resolve
+    "407 Proxy Authentication Required" errors that occur even when
+    all proxy environment variables are correctly set.
+
+    Note: This fix may not work with all thrift versions due to compatibility issues
+    between databricks-sql-connector 2.9.6 and newer thrift versions. The fix will
+    gracefully fail with a warning if thrift compatibility issues are detected.
+    The main SQL functionality will continue to work normally without this fix.
+    """
+    _log_proxy_environment()
+    logger.info("Applying databricks-sql proxy authentication fix...")
+
+    try:
+        _ensure_thrift_imports()
+        import databricks.sql.auth.thrift_http_client as thrift_http
+
+        # Store original method for fallback
+        original_open = getattr(thrift_http.THttpClient, "open", None)
+        if not original_open:
+            logger.warning("Could not find THttpClient.open method to patch")
+            return False
+
+        logger.debug(f"Found THttpClient.open method at {original_open}")
+
+        # Apply the patch
+        patched_open = _create_patched_open_method(original_open)
+        thrift_http.THttpClient.open = patched_open
+        logger.info("Successfully applied databricks-sql proxy authentication fix")
+
+        # Verify the patch was applied
+        current_method = getattr(thrift_http.THttpClient, "open", None)
+        if current_method == patched_open:
+            logger.debug(
+                "Patch verification successful: THttpClient.open is now the patched version"
+            )
+            return True
+        else:
+            logger.warning(
+                "Patch verification failed: THttpClient.open was not replaced correctly"
+            )
+            return False
+
+    except ImportError as e:
+        logger.debug(f"Could not import databricks-sql internals for proxy patch: {e}")
+        return False
+    except AttributeError as e:
+        if "thrift" in str(e).lower() and "transport" in str(e).lower():
+            warning_msg = (
+                f"Databricks-sql proxy authentication patch could not be applied due to thrift version incompatibility: {e}. "
+                "In most environments, the SQL connection will still work without this patch."
+            )
+            logger.warning(warning_msg)
+            # Import here to avoid circular imports
+            from datahub.utilities.global_warning_util import add_global_warning
+
+            add_global_warning(warning_msg)
+        else:
+            logger.error(
+                f"Failed to apply databricks-sql proxy patch: {e}", exc_info=True
+            )
+        return False
+    except Exception as e:
+        logger.error(f"Failed to apply databricks-sql proxy patch: {e}", exc_info=True)
+        return False

datahub/ingestion/source/unity/source.py

@@ -257,6 +257,18 @@ class UnityCatalogSource(StatefulIngestionSourceBase, TestableSource):
         else:
             self.platform_resource_repository = None
 
+        if self.config._forced_disable_tag_extraction:
+            self.report.report_warning(
+                "Some features disabled because of configuration conflicts",
+                "Tag Extraction is disabled due to missing warehouse_id in config",
+            )
+
+        if self.config._forced_disable_hive_metastore_extraction:
+            self.report.report_warning(
+                "Some features disabled because of configuration conflicts",
+                "Hive Metastore Extraction is disabled due to missing warehouse_id in config",
+            )
+
         # Include platform resource repository in report for automatic cache statistics
         if self.config.include_tags and self.platform_resource_repository:
             self.report.tag_urn_resolver_cache = self.platform_resource_repository

datahub/ingestion/source/usage/usage_common.py

@@ -268,6 +268,7 @@ class UsageAggregator(Generic[ResourceType]):
             user,
             query,
             fields,
+            user_email_pattern=self.config.user_email_pattern,
             count=count,
         )
 

datahub/sdk/chart.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Dict, List, Optional, Type, Union
 
+from deprecated.sphinx import deprecated
 from typing_extensions import Self
 
 import datahub.metadata.schema_classes as models
@@ -23,11 +24,13 @@ from datahub.sdk._shared import (
     HasTerms,
     LinksInputType,
     OwnersInputType,
+    ParentContainerInputType,
     TagsInputType,
     TermsInputType,
 )
 from datahub.sdk.dataset import Dataset
 from datahub.sdk.entity import Entity, ExtraAspectsType
+from datahub.utilities.sentinels import Unset, unset
 
 
 class Chart(
@@ -70,14 +73,15 @@ class Chart(
         last_refreshed: Optional[datetime] = None,
         chart_type: Optional[Union[str, models.ChartTypeClass]] = None,
         access: Optional[str] = None,
+        input_datasets: Optional[List[Union[DatasetUrnOrStr, Dataset]]] = None,
         # Standard aspects.
+        parent_container: ParentContainerInputType | Unset = unset,
         subtype: Optional[str] = None,
         owners: Optional[OwnersInputType] = None,
         links: Optional[LinksInputType] = None,
         tags: Optional[TagsInputType] = None,
         terms: Optional[TermsInputType] = None,
         domain: Optional[DomainInputType] = None,
-        input_datasets: Optional[List[Union[DatasetUrnOrStr, Dataset]]] = None,
         extra_aspects: ExtraAspectsType = None,
     ):
         """Initialize a new Chart instance."""
@@ -91,19 +95,31 @@ class Chart(
 
         self._set_platform_instance(platform, platform_instance)
 
-        # Set additional properties
+        self._ensure_chart_props(display_name=display_name)
+
+        if display_name is not None:
+            self.set_display_name(display_name)
+        if description is not None:
+            self.set_description(description)
         if external_url is not None:
             self.set_external_url(external_url)
         if chart_url is not None:
             self.set_chart_url(chart_url)
         if custom_properties is not None:
             self.set_custom_properties(custom_properties)
+        if last_modified is not None:
+            self.set_last_modified(last_modified)
         if last_refreshed is not None:
             self.set_last_refreshed(last_refreshed)
         if chart_type is not None:
             self.set_chart_type(chart_type)
         if access is not None:
             self.set_access(access)
+        if input_datasets is not None:
+            self.set_input_datasets(input_datasets)
+
+        if parent_container is not unset:
+            self._set_container(parent_container)
         if subtype is not None:
             self.set_subtype(subtype)
         if owners is not None:
@@ -116,14 +132,6 @@ class Chart(
             self.set_terms(terms)
         if domain is not None:
             self.set_domain(domain)
-        if last_modified is not None:
-            self.set_last_modified(last_modified)
-        if input_datasets is not None:
-            self.set_input_datasets(input_datasets)
-        if description is not None:
-            self.set_description(description)
-        if display_name is not None:
-            self.set_display_name(display_name)
 
     @classmethod
     def _new_from_graph(cls, urn: Urn, current_aspects: models.AspectBag) -> Self:
@@ -139,11 +147,13 @@ class Chart(
         assert isinstance(self._urn, ChartUrn)
         return self._urn
 
-    def _ensure_chart_props(self) -> models.ChartInfoClass:
+    def _ensure_chart_props(
+        self, display_name: Optional[str] = None
+    ) -> models.ChartInfoClass:
         """Ensure chart properties exist, using a safer approach."""
         return self._setdefault_aspect(
             models.ChartInfoClass(
-                title=self.urn.chart_id,
+                title=display_name or self.urn.chart_id,
                 description="",
                 lastModified=models.ChangeAuditStampsClass(),
             )
@@ -155,13 +165,15 @@ class Chart(
         return self.urn.chart_id
 
     @property
+    @deprecated("Use display_name instead", version="1.2.0.7")
     def title(self) -> str:
-        """Get the title of the chart."""
-        return self._ensure_chart_props().title
+        """Get the display name of the chart."""
+        return self.display_name
 
+    @deprecated("Use set_display_name instead", version="1.2.0.7")
     def set_title(self, title: str) -> None:
-        """Set the title of the chart."""
-        self._ensure_chart_props().title = title
+        """Set the display name of the chart."""
+        self.set_display_name(title)
 
     @property
     def description(self) -> Optional[str]:
@@ -173,13 +185,13 @@ class Chart(
         self._ensure_chart_props().description = description
 
     @property
-    def display_name(self) -> Optional[str]:
+    def display_name(self) -> str:
         """Get the display name of the chart."""
-        return self.title
+        return self._ensure_chart_props().title
 
     def set_display_name(self, display_name: str) -> None:
         """Set the display name of the chart."""
-        self.set_title(display_name)
+        self._ensure_chart_props().title = display_name
 
     @property
     def external_url(self) -> Optional[str]:
@@ -250,9 +262,11 @@ class Chart(
     def set_chart_type(self, chart_type: Union[str, models.ChartTypeClass]) -> None:
         """Set the type of the chart."""
         if isinstance(chart_type, str):
-            assert chart_type in get_enum_options(models.ChartTypeClass), (
-                f"Invalid chart type: {chart_type}"
-            )
+            chart_type_options = get_enum_options(models.ChartTypeClass)
+            if chart_type not in chart_type_options:
+                raise ValueError(
+                    f"Invalid chart type: {chart_type}; valid types are {chart_type_options}"
+                )
         self._ensure_chart_props().type = chart_type
 
     @property