azpaddypy 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

azpaddypy/__init__.py

@@ -0,0 +1,2 @@
+from .mgmt import *
+from .resources import *

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.4.dist-info → azpaddypy-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azpaddypy
-Version: 0.3.4
+Version: 0.3.6
 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.6.dist-info/RECORD

@@ -0,0 +1,11 @@
+azpaddypy/__init__.py,sha256=hrWNAh4OHZOvm3Pbhq5eUjO-pSRYn0h0W0J87tc-lNI,45
+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.6.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
+azpaddypy-0.3.6.dist-info/METADATA,sha256=jTLf8ztnMvo9Mlzma_k3Ck9kR7XpiDGse6SiPca9zeE,665
+azpaddypy-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+azpaddypy-0.3.6.dist-info/top_level.txt,sha256=hsDuboDhT61320ML8X479ezSTwT3rrlDWz1_Z45B2cs,10
+azpaddypy-0.3.6.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.4.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=pivPsHeySF1Dyx6HKCSos7HBOYyJMVeRP25wYZu3Sno,35117
-azpaddypy/test_function/__init__.py,sha256=0NjUl36wvUWV79GpRwBFkgkBaC6uDZsTdaSVOIHMFEU,3481
-azpaddypy/test_function/function_app.py,sha256=6nX54-iq0L1l_hZpD6E744-j79oLxdaldFyWDCpwH7c,3867
-azpaddypy-0.3.4.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
-azpaddypy-0.3.4.dist-info/METADATA,sha256=QDqVtpO7pbf_VGJM4e3W6QHV0VtOB3gc6kH8pAoe7jQ,705
-azpaddypy-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-azpaddypy-0.3.4.dist-info/top_level.txt,sha256=hsDuboDhT61320ML8X479ezSTwT3rrlDWz1_Z45B2cs,10
-azpaddypy-0.3.4.dist-info/RECORD,,