azpaddypy 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

azpaddypy/mgmt/logging.py

@@ -3,6 +3,7 @@ import os
 import functools
 import time
 import asyncio
+import uuid
 from typing import Optional, Dict, Any, Union, Callable
 from datetime import datetime
 from azure.monitor.opentelemetry import configure_azure_monitor
@@ -19,12 +20,23 @@ class AzureLogger:
     tracking, baggage propagation, and automated function tracing for Azure
     applications with seamless local development support.
 
+    CLOUD ROLE NAME INTEGRATION:
+    The service_name parameter automatically sets the cloud role name for 
+    Application Insights. When multiple services emit telemetry to the same 
+    Application Insights resource, each service will appear as a separate 
+    node on the Application Map, enabling proper service topology visualization.
+
+    CORRELATION ID AUTOMATION:
+    The trace_function decorator automatically generates UUID4 correlation IDs
+    when none are manually set, ensuring consistent distributed tracing across
+    all function calls without requiring manual configuration.
+
     Supports all standard logging levels (debug, info, warning, error, exception, 
     critical) with enhanced context including trace IDs, correlation IDs, and 
     baggage propagation.
 
     Attributes:
-        service_name: Service identifier for telemetry
+        service_name: Service identifier for telemetry and cloud role name
         service_version: Service version for context
         connection_string: Application Insights connection string
         logger: Python logger instance
@@ -40,17 +52,24 @@ class AzureLogger:
         enable_console_logging: bool = True,
         custom_resource_attributes: Optional[Dict[str, str]] = None,
         instrumentation_options: Optional[Dict[str, Any]] = None,
+        cloud_role_name: Optional[str] = None,
     ):
         """Initialize Azure Logger with OpenTelemetry tracing.
 
+        The service_name parameter automatically sets the cloud role name for 
+        Application Insights Application Map visualization. When multiple services
+        emit telemetry to the same Application Insights resource, each service
+        will appear as a separate node on the Application Map.
+
         Args:
-            service_name: Service identifier for telemetry
+            service_name: Service identifier for telemetry and cloud role name
             service_version: Service version for metadata
             connection_string: Application Insights connection string
             log_level: Python logging level (default: INFO)
             enable_console_logging: Enable console output for local development
             custom_resource_attributes: Additional OpenTelemetry resource attributes
             instrumentation_options: Azure Monitor instrumentation options
+            cloud_role_name: Override cloud role name (defaults to service_name)
         """
         self.service_name = service_name
         self.service_version = service_version
@@ -58,9 +77,14 @@ class AzureLogger:
             "APPLICATIONINSIGHTS_CONNECTION_STRING"
         )
 
+        # Use explicit cloud role name or default to service name
+        effective_cloud_role_name = cloud_role_name or service_name
+        self.cloud_role_name = effective_cloud_role_name
+
         # Configure resource attributes
+        # NOTE: service.name automatically maps to cloud role name in Application Insights
         resource_attributes = {
-            "service.name": service_name,
+            "service.name": effective_cloud_role_name,
             "service.version": service_version,
             "service.instance.id": os.getenv("WEBSITE_INSTANCE_ID", "local"),
         }
@@ -100,7 +124,8 @@ class AzureLogger:
         self._correlation_id = None
 
         self.info(
-            f"Azure Logger initialized for service '{service_name}' v{service_version}"
+            f"Azure Logger initialized for service '{service_name}' v{service_version} "
+            f"(cloud role: '{effective_cloud_role_name}')"
         )
 
     def _setup_console_handler(self):
@@ -115,16 +140,27 @@ class AzureLogger:
     def set_correlation_id(self, correlation_id: str):
         """Set correlation ID for request/transaction tracking.
 
+        Manually sets the correlation ID that will be used for all subsequent
+        tracing operations. This value takes precedence over auto-generated
+        correlation IDs in the trace_function decorator.
+
         Args:
             correlation_id: Unique identifier for transaction correlation
+
+        Note:
+            If not set manually, the trace_function decorator will automatically
+            generate a UUID4 correlation_id on first use.
         """
         self._correlation_id = correlation_id
 
     def get_correlation_id(self) -> Optional[str]:
         """Get current correlation ID.
 
+        Returns the currently active correlation ID, whether manually set
+        or automatically generated by the trace_function decorator.
+
         Returns:
-            Current correlation ID if set, otherwise None
+            Current correlation ID if set (manual or auto-generated), otherwise None
         """
         return self._correlation_id
 
@@ -510,16 +546,38 @@ class AzureLogger:
         log_args: bool = True,
         log_result: bool = False
     ) -> Callable:
-        """Decorator for automatic function execution tracing.
+        """Decorator for automatic function execution tracing with correlation ID support.
 
         Supports both synchronous and asynchronous functions with comprehensive
-        logging and OpenTelemetry span creation.
+        logging and OpenTelemetry span creation. Automatically generates and manages
+        correlation IDs for distributed tracing.
+
+        CORRELATION ID AUTOMATION:
+        - If no correlation_id is set, automatically generates a UUID4 correlation_id
+        - If correlation_id is manually set, preserves the existing value
+        - Correlation_id is automatically added to all spans and log entries
+        - Ensures consistent tracing across function calls
 
         Args:
             function_name: Custom span name (defaults to function name)
             log_execution: Whether to log execution metrics
             log_args: Whether to log function arguments
             log_result: Whether to log function result
+
+        Returns:
+            Decorated function with automatic tracing and correlation ID support
+
+        Example:
+            # Automatic correlation_id generation
+            @logger.trace_function()
+            def my_function():
+                return "result"
+
+            # Manual correlation_id (preserved)
+            logger.set_correlation_id("manual-id")
+            @logger.trace_function()
+            def my_function():
+                return "result"
         """
 
         def decorator(func):
@@ -527,6 +585,11 @@ class AzureLogger:
             async def async_wrapper(*args, **kwargs):
                 span_name = function_name or f"{func.__module__}.{func.__name__}"
                 with self.tracer.start_as_current_span(span_name) as span:
+                    # Auto-generate correlation_id if not set - ensures consistent tracing
+                    # Manual correlation_ids take precedence over auto-generated ones
+                    if not self._correlation_id:
+                        self._correlation_id = str(uuid.uuid4())
+                    
                     self._setup_span_for_function_trace(
                         span, func, True, log_args, args, kwargs, log_result, log_execution
                     )
@@ -560,6 +623,11 @@ class AzureLogger:
             def sync_wrapper(*args, **kwargs):
                 span_name = function_name or f"{func.__module__}.{func.__name__}"
                 with self.tracer.start_as_current_span(span_name) as span:
+                    # Auto-generate correlation_id if not set - ensures consistent tracing
+                    # Manual correlation_ids take precedence over auto-generated ones
+                    if not self._correlation_id:
+                        self._correlation_id = str(uuid.uuid4())
+                    
                     self._setup_span_for_function_trace(
                         span, func, False, log_args, args, kwargs, log_result, log_execution
                     )
@@ -704,19 +772,23 @@ def create_app_logger(
     enable_console_logging: bool = True,
     custom_resource_attributes: Optional[Dict[str, str]] = None,
     instrumentation_options: Optional[Dict[str, Any]] = None,
+    cloud_role_name: Optional[str] = None,
 ) -> AzureLogger:
     """Create cached AzureLogger instance for applications.
 
     Returns existing logger if one with same configuration exists.
+    The service_name automatically becomes the cloud role name in Application Insights
+    unless explicitly overridden with cloud_role_name parameter.
 
     Args:
-        service_name: Service identifier for telemetry
+        service_name: Service identifier for telemetry and cloud role name
         service_version: Service version for metadata
         connection_string: Application Insights connection string
         log_level: Python logging level
         enable_console_logging: Enable console output
         custom_resource_attributes: Additional OpenTelemetry resource attributes
         instrumentation_options: Azure Monitor instrumentation options
+        cloud_role_name: Override cloud role name (defaults to service_name)
 
     Returns:
         Configured AzureLogger instance
@@ -738,6 +810,7 @@ def create_app_logger(
         log_level,
         enable_console_logging,
         attr_items,
+        cloud_role_name,
     )
 
     if params_key in _loggers:
@@ -750,6 +823,8 @@ def create_app_logger(
         log_level=log_level,
         enable_console_logging=enable_console_logging,
         custom_resource_attributes=custom_resource_attributes,
+        instrumentation_options=instrumentation_options,
+        cloud_role_name=cloud_role_name,
     )
     _loggers[params_key] = logger
     return logger
@@ -761,15 +836,21 @@ def create_function_logger(
     service_version: str = "1.0.0",
     connection_string: Optional[str] = None,
     instrumentation_options: Optional[Dict[str, Any]] = None,
+    cloud_role_name: Optional[str] = None,
 ) -> AzureLogger:
     """Create AzureLogger optimized for Azure Functions.
 
+    Automatically creates cloud role name in the format '{function_app_name}.{function_name}'
+    unless explicitly overridden. This ensures each function appears as a separate
+    component in the Application Insights Application Map.
+
     Args:
         function_app_name: Azure Function App name
         function_name: Specific function name
         service_version: Service version for metadata
         connection_string: Application Insights connection string
         instrumentation_options: Azure Monitor instrumentation options
+        cloud_role_name: Override cloud role name (defaults to '{function_app_name}.{function_name}')
 
     Returns:
         Configured AzureLogger with Azure Functions context
@@ -780,10 +861,13 @@ def create_function_logger(
         "azure.resource.type": "function",
     }
 
+    default_service_name = f"{function_app_name}.{function_name}"
+
     return create_app_logger(
-        service_name=f"{function_app_name}.{function_name}",
+        service_name=default_service_name,
         service_version=service_version,
         connection_string=connection_string,
         custom_resource_attributes=custom_attributes,
         instrumentation_options=instrumentation_options,
+        cloud_role_name=cloud_role_name,
     )

azpaddypy/resources/__init__.py

@@ -0,0 +1,12 @@
+"""Azure resources package for azpaddypy.
+
+This package contains modules for interacting with various Azure resources
+including Key Vault, Storage, and other Azure services.
+"""
+
+from .keyvault import AzureKeyVault, create_azure_keyvault
+
+__all__ = [
+    "AzureKeyVault",
+    "create_azure_keyvault",
+] 

azpaddypy/resources/keyvault.py

@@ -0,0 +1,530 @@
+from typing import Optional, Dict, Any, Union, List
+from azure.keyvault.secrets import SecretClient
+from azure.keyvault.keys import KeyClient
+from azure.keyvault.certificates import CertificateClient
+from azure.core.exceptions import ResourceNotFoundError, ClientAuthenticationError
+from azure.core.credentials import TokenCredential
+from ..mgmt.logging import AzureLogger
+from ..mgmt.identity import AzureIdentity
+
+
+class AzureKeyVault:
+    """Azure Key Vault management with comprehensive secret, key, and certificate operations.
+
+    Provides standardized Azure Key Vault operations using Azure SDK clients
+    with integrated logging, error handling, and OpenTelemetry tracing support.
+    Supports operations for secrets, keys, and certificates with proper
+    authentication and authorization handling.
+
+    Attributes:
+        vault_url: Azure Key Vault URL
+        service_name: Service identifier for logging and tracing
+        service_version: Service version for context
+        logger: AzureLogger instance for structured logging
+        credential: Azure credential for authentication
+        secret_client: Azure Key Vault SecretClient instance
+        key_client: Azure Key Vault KeyClient instance
+        certificate_client: Azure Key Vault CertificateClient instance
+    """
+
+    def __init__(
+        self,
+        vault_url: str,
+        credential: Optional[TokenCredential] = None,
+        azure_identity: Optional[AzureIdentity] = None,
+        service_name: str = "azure_keyvault",
+        service_version: str = "1.0.0",
+        logger: Optional[AzureLogger] = None,
+        connection_string: Optional[str] = None,
+        enable_secrets: bool = True,
+        enable_keys: bool = True,
+        enable_certificates: bool = True,
+    ):
+        """Initialize Azure Key Vault with comprehensive configuration.
+
+        Args:
+            vault_url: Azure Key Vault URL (e.g., https://vault.vault.azure.net/)
+            credential: Azure credential for authentication
+            azure_identity: AzureIdentity instance for credential management
+            service_name: Service name for tracing context
+            service_version: Service version for metadata
+            logger: Optional AzureLogger instance
+            connection_string: Application Insights connection string
+            enable_secrets: Enable secret operations client
+            enable_keys: Enable key operations client
+            enable_certificates: Enable certificate operations client
+
+        Raises:
+            ValueError: If neither credential nor azure_identity is provided
+            Exception: If client initialization fails
+        """
+        self.vault_url = vault_url
+        self.service_name = service_name
+        self.service_version = service_version
+        self.enable_secrets = enable_secrets
+        self.enable_keys = enable_keys
+        self.enable_certificates = enable_certificates
+
+        # Initialize logger - use provided instance or create new one
+        if logger is not None:
+            self.logger = logger
+        else:
+            self.logger = AzureLogger(
+                service_name=service_name,
+                service_version=service_version,
+                connection_string=connection_string,
+                enable_console_logging=True,
+            )
+
+        # Setup credential
+        if azure_identity is not None:
+            self.credential = azure_identity.get_credential()
+            self.azure_identity = azure_identity
+        elif credential is not None:
+            self.credential = credential
+            self.azure_identity = None
+        else:
+            raise ValueError("Either 'credential' or 'azure_identity' must be provided")
+
+        # Initialize clients
+        self.secret_client = None
+        self.key_client = None
+        self.certificate_client = None
+        
+        self._setup_clients()
+
+        self.logger.info(
+            f"Azure Key Vault initialized for service '{service_name}' v{service_version}",
+            extra={
+                "vault_url": vault_url,
+                "secrets_enabled": enable_secrets,
+                "keys_enabled": enable_keys,
+                "certificates_enabled": enable_certificates,
+            }
+        )
+
+    def _setup_clients(self):
+        """Initialize Key Vault clients based on enabled features.
+
+        Raises:
+            Exception: If client initialization fails
+        """
+        try:
+            if self.enable_secrets:
+                self.secret_client = SecretClient(
+                    vault_url=self.vault_url,
+                    credential=self.credential
+                )
+                self.logger.debug("SecretClient initialized successfully")
+
+            if self.enable_keys:
+                self.key_client = KeyClient(
+                    vault_url=self.vault_url,
+                    credential=self.credential
+                )
+                self.logger.debug("KeyClient initialized successfully")
+
+            if self.enable_certificates:
+                self.certificate_client = CertificateClient(
+                    vault_url=self.vault_url,
+                    credential=self.credential
+                )
+                self.logger.debug("CertificateClient initialized successfully")
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to initialize Key Vault clients: {e}",
+                exc_info=True
+            )
+            raise
+
+    # Secret Operations
+    def get_secret(
+        self,
+        secret_name: str,
+        version: Optional[str] = None,
+        **kwargs
+    ) -> Optional[str]:
+        """Retrieve a secret from Azure Key Vault.
+
+        Args:
+            secret_name: Name of the secret
+            version: Optional specific version of the secret
+            **kwargs: Additional parameters for the secret retrieval
+
+        Returns:
+            Secret value if found, None if not found
+
+        Raises:
+            RuntimeError: If secret client is not initialized
+            Exception: If secret retrieval fails for reasons other than not found
+        """
+        with self.logger.create_span(
+            "AzureKeyVault.get_secret",
+            attributes={
+                "service.name": self.service_name,
+                "operation.type": "secret_retrieval",
+                "keyvault.secret_name": secret_name,
+                "keyvault.version": version or "latest",
+                "keyvault.vault_url": self.vault_url
+            }
+        ):
+            if self.secret_client is None:
+                error_msg = "Secret client not initialized. Enable secrets during initialization."
+                self.logger.error(error_msg)
+                raise RuntimeError(error_msg)
+
+            try:
+                self.logger.debug(
+                    "Retrieving secret from Key Vault",
+                    extra={
+                        "secret_name": secret_name,
+                        "version": version,
+                        "vault_url": self.vault_url
+                    }
+                )
+
+                secret = self.secret_client.get_secret(secret_name, version=version, **kwargs)
+                
+                self.logger.info(
+                    "Secret retrieved successfully",
+                    extra={
+                        "secret_name": secret_name,
+                        "version": secret.properties.version if secret.properties else None,
+                        "content_type": secret.properties.content_type if secret.properties else None
+                    }
+                )
+                
+                return secret.value
+
+            except ResourceNotFoundError:
+                self.logger.warning(
+                    f"Secret '{secret_name}' not found in Key Vault",
+                    extra={"secret_name": secret_name, "version": version}
+                )
+                return None
+            except ClientAuthenticationError as e:
+                self.logger.error(
+                    f"Authentication failed for secret '{secret_name}': {e}",
+                    extra={"secret_name": secret_name},
+                    exc_info=True
+                )
+                raise
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to retrieve secret '{secret_name}': {e}",
+                    extra={"secret_name": secret_name, "version": version},
+                    exc_info=True
+                )
+                raise
+
+    def set_secret(
+        self,
+        secret_name: str,
+        secret_value: str,
+        content_type: Optional[str] = None,
+        tags: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> bool:
+        """Set a secret in Azure Key Vault.
+
+        Args:
+            secret_name: Name of the secret
+            secret_value: Value of the secret
+            content_type: Optional content type for the secret
+            tags: Optional tags for the secret
+            **kwargs: Additional parameters for secret creation
+
+        Returns:
+            True if secret was set successfully
+
+        Raises:
+            RuntimeError: If secret client is not initialized
+            Exception: If secret creation fails
+        """
+        with self.logger.create_span(
+            "AzureKeyVault.set_secret",
+            attributes={
+                "service.name": self.service_name,
+                "operation.type": "secret_creation",
+                "keyvault.secret_name": secret_name,
+                "keyvault.content_type": content_type or "text/plain",
+                "keyvault.vault_url": self.vault_url
+            }
+        ):
+            if self.secret_client is None:
+                error_msg = "Secret client not initialized. Enable secrets during initialization."
+                self.logger.error(error_msg)
+                raise RuntimeError(error_msg)
+
+            try:
+                self.logger.debug(
+                    "Setting secret in Key Vault",
+                    extra={
+                        "secret_name": secret_name,
+                        "content_type": content_type,
+                        "has_tags": tags is not None,
+                        "vault_url": self.vault_url
+                    }
+                )
+
+                secret = self.secret_client.set_secret(
+                    secret_name,
+                    secret_value,
+                    content_type=content_type,
+                    tags=tags,
+                    **kwargs
+                )
+                
+                self.logger.info(
+                    "Secret set successfully",
+                    extra={
+                        "secret_name": secret_name,
+                        "version": secret.properties.version if secret.properties else None,
+                        "content_type": secret.properties.content_type if secret.properties else None
+                    }
+                )
+                
+                return True
+
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to set secret '{secret_name}': {e}",
+                    extra={"secret_name": secret_name, "content_type": content_type},
+                    exc_info=True
+                )
+                raise
+
+    def delete_secret(self, secret_name: str, **kwargs) -> bool:
+        """Delete a secret from Azure Key Vault.
+
+        Args:
+            secret_name: Name of the secret to delete
+            **kwargs: Additional parameters for secret deletion
+
+        Returns:
+            True if secret was deleted successfully
+
+        Raises:
+            RuntimeError: If secret client is not initialized
+            Exception: If secret deletion fails
+        """
+        with self.logger.create_span(
+            "AzureKeyVault.delete_secret",
+            attributes={
+                "service.name": self.service_name,
+                "operation.type": "secret_deletion",
+                "keyvault.secret_name": secret_name,
+                "keyvault.vault_url": self.vault_url
+            }
+        ):
+            if self.secret_client is None:
+                error_msg = "Secret client not initialized. Enable secrets during initialization."
+                self.logger.error(error_msg)
+                raise RuntimeError(error_msg)
+
+            try:
+                self.logger.debug(
+                    "Deleting secret from Key Vault",
+                    extra={"secret_name": secret_name, "vault_url": self.vault_url}
+                )
+
+                self.secret_client.begin_delete_secret(secret_name, **kwargs)
+                
+                self.logger.info(
+                    "Secret deletion initiated successfully",
+                    extra={"secret_name": secret_name}
+                )
+                
+                return True
+
+            except ResourceNotFoundError:
+                self.logger.warning(
+                    f"Secret '{secret_name}' not found for deletion",
+                    extra={"secret_name": secret_name}
+                )
+                return False
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to delete secret '{secret_name}': {e}",
+                    extra={"secret_name": secret_name},
+                    exc_info=True
+                )
+                raise
+
+    def list_secrets(self, **kwargs) -> List[str]:
+        """List all secrets in the Key Vault.
+
+        Args:
+            **kwargs: Additional parameters for listing secrets
+
+        Returns:
+            List of secret names
+
+        Raises:
+            RuntimeError: If secret client is not initialized
+            Exception: If listing secrets fails
+        """
+        with self.logger.create_span(
+            "AzureKeyVault.list_secrets",
+            attributes={
+                "service.name": self.service_name,
+                "operation.type": "secret_listing",
+                "keyvault.vault_url": self.vault_url
+            }
+        ):
+            if self.secret_client is None:
+                error_msg = "Secret client not initialized. Enable secrets during initialization."
+                self.logger.error(error_msg)
+                raise RuntimeError(error_msg)
+
+            try:
+                self.logger.debug(
+                    "Listing secrets from Key Vault",
+                    extra={"vault_url": self.vault_url}
+                )
+
+                secret_names = []
+                for secret_property in self.secret_client.list_properties_of_secrets(**kwargs):
+                    secret_names.append(secret_property.name)
+                
+                self.logger.info(
+                    "Secrets listed successfully",
+                    extra={"secret_count": len(secret_names)}
+                )
+                
+                return secret_names
+
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to list secrets: {e}",
+                    exc_info=True
+                )
+                raise
+
+    def test_connection(self) -> bool:
+        """Test connection to Key Vault by attempting to list secrets.
+
+        Returns:
+            True if connection is successful, False otherwise
+        """
+        with self.logger.create_span(
+            "AzureKeyVault.test_connection",
+            attributes={
+                "service.name": self.service_name,
+                "operation.type": "connection_test",
+                "keyvault.vault_url": self.vault_url
+            }
+        ):
+            try:
+                self.logger.debug(
+                    "Testing Key Vault connection",
+                    extra={"vault_url": self.vault_url}
+                )
+
+                if self.secret_client is not None:
+                    # Try to list secrets (limited to 1) to test connection
+                    list(self.secret_client.list_properties_of_secrets(max_page_size=1))
+                elif self.key_client is not None:
+                    # Try to list keys if secrets are disabled
+                    list(self.key_client.list_properties_of_keys(max_page_size=1))
+                elif self.certificate_client is not None:
+                    # Try to list certificates if keys are disabled
+                    list(self.certificate_client.list_properties_of_certificates(max_page_size=1))
+                else:
+                    self.logger.error("No clients available for connection testing")
+                    return False
+
+                self.logger.info("Key Vault connection test successful")
+                return True
+
+            except Exception as e:
+                self.logger.warning(
+                    f"Key Vault connection test failed: {e}",
+                    extra={"vault_url": self.vault_url}
+                )
+                return False
+
+    def set_correlation_id(self, correlation_id: str):
+        """Set correlation ID for request/transaction tracking.
+
+        Args:
+            correlation_id: Unique identifier for transaction correlation
+        """
+        self.logger.set_correlation_id(correlation_id)
+
+    def get_correlation_id(self) -> Optional[str]:
+        """Get current correlation ID.
+
+        Returns:
+            Current correlation ID if set, otherwise None
+        """
+        return self.logger.get_correlation_id()
+
+
+def create_azure_keyvault(
+    vault_url: str,
+    credential: Optional[TokenCredential] = None,
+    azure_identity: Optional[AzureIdentity] = None,
+    service_name: str = "azure_keyvault",
+    service_version: str = "1.0.0",
+    logger: Optional[AzureLogger] = None,
+    connection_string: Optional[str] = None,
+    enable_secrets: bool = True,
+    enable_keys: bool = True,
+    enable_certificates: bool = True,
+) -> AzureKeyVault:
+    """Factory function to create AzureKeyVault instance.
+
+    Provides a convenient way to create an AzureKeyVault instance with
+    common configuration patterns. If no credential or azure_identity
+    is provided, creates a default AzureIdentity instance.
+
+    Args:
+        vault_url: Azure Key Vault URL
+        credential: Azure credential for authentication
+        azure_identity: AzureIdentity instance for credential management
+        service_name: Service name for tracing context
+        service_version: Service version for metadata
+        logger: Optional AzureLogger instance
+        connection_string: Application Insights connection string
+        enable_secrets: Enable secret operations client
+        enable_keys: Enable key operations client
+        enable_certificates: Enable certificate operations client
+
+    Returns:
+        Configured AzureKeyVault instance
+
+    Example:
+        # Basic usage with default credential
+        kv = create_azure_keyvault("https://vault.vault.azure.net/")
+        
+        # With custom service name and specific features
+        kv = create_azure_keyvault(
+            "https://vault.vault.azure.net/",
+            service_name="my_app",
+            enable_keys=False,
+            enable_certificates=False
+        )
+    """
+    if credential is None and azure_identity is None:
+        # Create default AzureIdentity instance
+        from ..mgmt.identity import create_azure_identity
+        azure_identity = create_azure_identity(
+            service_name=f"{service_name}_identity",
+            service_version=service_version,
+            connection_string=connection_string,
+        )
+
+    return AzureKeyVault(
+        vault_url=vault_url,
+        credential=credential,
+        azure_identity=azure_identity,
+        service_name=service_name,
+        service_version=service_version,
+        logger=logger,
+        connection_string=connection_string,
+        enable_secrets=enable_secrets,
+        enable_keys=enable_keys,
+        enable_certificates=enable_certificates,
+    )

{azpaddypy-0.3.3.dist-info → azpaddypy-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azpaddypy
-Version: 0.3.3
+Version: 0.3.5
 Summary: Comprehensive Python logger for Azure, integrating OpenTelemetry for advanced, structured, and distributed tracing.
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
@@ -9,9 +9,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: azure-monitor-opentelemetry==1.6.10
 Requires-Dist: azure-functions==1.23.0
-Provides-Extra: dev
-Requires-Dist: azure-functions==1.23.0; extra == "dev"
-Requires-Dist: pytest==8.4.1; extra == "dev"
-Requires-Dist: pytest-asyncio==1.0.0; extra == "dev"
-Requires-Dist: anyio==4.9.0; extra == "dev"
+Requires-Dist: azure-identity==1.23.0
+Requires-Dist: azure-keyvault-secrets==4.10.0
+Requires-Dist: azure-keyvault-keys==4.10.0
+Requires-Dist: azure-keyvault-certificates==4.10.0
 Dynamic: license-file

azpaddypy-0.3.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+azpaddypy/mgmt/__init__.py,sha256=-jH8Ftx9C8qu4yF5dMVEapVZhNwG7m4QCUjyutesOoY,278
+azpaddypy/mgmt/identity.py,sha256=mA_krQslMsK_sDob-z-QA0B9khK_JUO2way7xwPopR8,12001
+azpaddypy/mgmt/logging.py,sha256=pivPsHeySF1Dyx6HKCSos7HBOYyJMVeRP25wYZu3Sno,35117
+azpaddypy/resources/__init__.py,sha256=Bvt3VK4RqwoxYpoh6EbLXIR18RuFPKaLP6zLL-icyFk,314
+azpaddypy/resources/keyvault.py,sha256=4J08vLqoLFd1_UUDBji2oG2fatZaPkgnRyT_Z6wHAOc,20312
+azpaddypy-0.3.5.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
+azpaddypy-0.3.5.dist-info/METADATA,sha256=m56dD6Ev3sTewyiNU-UgPzw6L73idRtUlCM5o7lOwjg,665
+azpaddypy-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+azpaddypy-0.3.5.dist-info/top_level.txt,sha256=hsDuboDhT61320ML8X479ezSTwT3rrlDWz1_Z45B2cs,10
+azpaddypy-0.3.5.dist-info/RECORD,,

azpaddypy/test_function/__init__.py

@@ -1,112 +0,0 @@
-import logging
-import json
-import time
-import azure.functions as func
-from azpaddypy.mgmt.logging import create_function_logger
-
-# Initialize the logger
-logger = create_function_logger(
-    function_app_name="test-function-app", function_name="test-function"
-)
-
-
-@logger.trace_function(log_args=True, log_result=True)
-def process_request(req_body: dict) -> dict:
-    """Process the request body and return a response"""
-    # Simulate some processing time
-    time.sleep(0.1)
-
-    # Log the request processing
-    logger.info(
-        "Processing request",
-        extra={
-            "request_id": req_body.get("request_id", "unknown"),
-            "action": req_body.get("action", "unknown"),
-        },
-    )
-
-    return {
-        "status": "success",
-        "message": "Request processed successfully",
-        "data": req_body,
-    }
-
-
-def main(req: func.HttpRequest) -> func.HttpResponse:
-    """Azure Function entry point"""
-    try:
-        # Start timing the request
-        start_time = time.time()
-
-        # Get request details
-        method = req.method
-        url = req.url
-        headers = dict(req.headers)
-
-        # Log the incoming request
-        logger.log_request(
-            method=method,
-            url=url,
-            status_code=200,  # We'll update this if there's an error
-            duration_ms=0,  # We'll update this at the end
-            extra={"headers": headers, "request_type": "http_trigger"},
-        )
-
-        # Create a span for the entire function execution
-        with logger.create_span("function_execution") as span:
-            # Add request metadata to the span
-            span.set_attribute("http.method", method)
-            span.set_attribute("http.url", url)
-
-            # Parse request body
-            try:
-                req_body = req.get_json()
-            except ValueError:
-                req_body = {}
-
-            # Log the request body
-            logger.info("Received request body", extra={"body": req_body})
-
-            # Process the request
-            result = process_request(req_body)
-
-            # Calculate request duration
-            duration_ms = (time.time() - start_time) * 1000
-
-            # Log successful completion
-            logger.log_function_execution(
-                function_name="main",
-                duration_ms=duration_ms,
-                success=True,
-                extra={"method": method, "url": url},
-            )
-
-            # Return the response
-            return func.HttpResponse(
-                json.dumps(result), mimetype="application/json", status_code=200
-            )
-
-    except Exception as e:
-        # Calculate request duration
-        duration_ms = (time.time() - start_time) * 1000
-
-        # Log the error
-        logger.error(
-            f"Error processing request: {str(e)}",
-            extra={"method": method, "url": url, "error_type": type(e).__name__},
-        )
-
-        # Log failed execution
-        logger.log_function_execution(
-            function_name="main",
-            duration_ms=duration_ms,
-            success=False,
-            extra={"error": str(e), "error_type": type(e).__name__},
-        )
-
-        # Return error response
-        return func.HttpResponse(
-            json.dumps({"status": "error", "message": str(e)}),
-            mimetype="application/json",
-            status_code=500,
-        )

azpaddypy/test_function/function_app.py

@@ -1,129 +0,0 @@
-import logging
-import json
-import time
-import asyncio
-import azure.functions as func
-from azpaddypy.mgmt.logging import create_function_logger
-
-app = func.FunctionApp()
-
-# Initialize the logger
-logger = create_function_logger(
-    function_app_name="test-function-app", function_name="test-function"
-)
-
-
-@logger.trace_function(log_args=True, log_result=True)
-def process_request(req_body: dict) -> dict:
-    """Process the request body and return a response"""
-    # Simulate some processing time
-    time.sleep(0.1)
-
-    # Log the request processing
-    logger.info(
-        "Processing request",
-        extra={
-            "request_id": req_body.get("request_id", "unknown"),
-            "action": req_body.get("action", "unknown"),
-        },
-    )
-
-    return {
-        "status": "success",
-        "message": "Request processed successfully",
-        "data": req_body,
-    }
-
-
-@logger.trace_function(log_args=True, log_result=True)
-async def process_request_async(req_body: dict) -> dict:
-    """Process the request body asynchronously and return a response"""
-    # Simulate some async processing time
-    await asyncio.sleep(0.1)
-
-    # Log the request processing
-    logger.info(
-        "Processing async request",
-        extra={
-            "request_id": req_body.get("request_id", "unknown"),
-            "action": req_body.get("action", "unknown"),
-            "is_async": True,
-        },
-    )
-
-    return {
-        "status": "success",
-        "message": "Async request processed successfully",
-        "data": req_body,
-    }
-
-
-@app.function_name(name="test-function")
-@app.route(route="test-function", auth_level=func.AuthLevel.ANONYMOUS)
-async def test_function(req: func.HttpRequest) -> func.HttpResponse:
-    """Azure Function HTTP trigger that processes requests both synchronously and asynchronously"""
-    start_time = time.time()
-    method = req.method
-    url = str(req.url)
-
-    try:
-        # Get request body
-        req_body = req.get_json()
-
-        # Process request based on the action
-        action = req_body.get("action", "").lower()
-
-        if action == "async":
-            # Process request asynchronously
-            result = await process_request_async(req_body)
-        else:
-            # Process request synchronously
-            result = process_request(req_body)
-
-        # Calculate request duration
-        duration_ms = (time.time() - start_time) * 1000
-
-        # Log successful request
-        logger.log_request(
-            method=method,
-            url=url,
-            status_code=200,
-            duration_ms=duration_ms,
-            extra={
-                "request_id": req_body.get("request_id", "unknown"),
-                "action": action,
-                "is_async": action == "async",
-            },
-        )
-
-        # Return success response
-        return func.HttpResponse(
-            json.dumps(result),
-            mimetype="application/json",
-            status_code=200,
-        )
-
-    except Exception as e:
-        # Calculate request duration
-        duration_ms = (time.time() - start_time) * 1000
-
-        # Log the error
-        logger.error(
-            f"Error processing request: {str(e)}",
-            extra={"method": method, "url": url, "error_type": type(e).__name__},
-        )
-
-        # Log failed execution
-        logger.log_function_execution(
-            function_name="test_function",
-            duration_ms=duration_ms,
-            success=False,
-            extra={"error": str(e), "error_type": type(e).__name__},
-        )
-
-        # Return error response
-        return func.HttpResponse(
-            json.dumps({"status": "error", "message": str(e)}),
-            mimetype="application/json",
-            status_code=500,
-        )

azpaddypy-0.3.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-azpaddypy/mgmt/__init__.py,sha256=-jH8Ftx9C8qu4yF5dMVEapVZhNwG7m4QCUjyutesOoY,278
-azpaddypy/mgmt/identity.py,sha256=mA_krQslMsK_sDob-z-QA0B9khK_JUO2way7xwPopR8,12001
-azpaddypy/mgmt/logging.py,sha256=Cz_xPjFYfiNh2_S7jww8QR1EaGgQfXcFzEWZqCDp8ks,30638
-azpaddypy/test_function/__init__.py,sha256=0NjUl36wvUWV79GpRwBFkgkBaC6uDZsTdaSVOIHMFEU,3481
-azpaddypy/test_function/function_app.py,sha256=6nX54-iq0L1l_hZpD6E744-j79oLxdaldFyWDCpwH7c,3867
-azpaddypy-0.3.3.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
-azpaddypy-0.3.3.dist-info/METADATA,sha256=8Pnqt9ZOhDafwPlx2VeC_Zknadyb9kHBPv76Ss-OPLQ,705
-azpaddypy-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-azpaddypy-0.3.3.dist-info/top_level.txt,sha256=hsDuboDhT61320ML8X479ezSTwT3rrlDWz1_Z45B2cs,10
-azpaddypy-0.3.3.dist-info/RECORD,,