azpaddypy 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

{azpaddypy-0.1.5.dist-info → azpaddypy-0.1.7.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: azpaddypy
-Version: 0.1.5
+Version: 0.1.7
 Summary: Add your description here
-Author-email: Patrik <patrikhartl@gmail.com>
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: azure-monitor-opentelemetry==1.6.10
 Dynamic: license-file

azpaddypy-0.1.7.dist-info/RECORD

@@ -0,0 +1,9 @@
+azpaddypy-0.1.7.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
+mgmt/__init__.py,sha256=5-0eZuJMZlCONZNJ5hEvWXfvLIM36mg7FsEVs32bY_A,183
+mgmt/logging.py,sha256=9u114Ji-cwBMUf8D02i_b_Ei2dZc3TaIUH4uJv_tmSc,25451
+test_function/__init__.py,sha256=0NjUl36wvUWV79GpRwBFkgkBaC6uDZsTdaSVOIHMFEU,3481
+test_function/function_app.py,sha256=6nX54-iq0L1l_hZpD6E744-j79oLxdaldFyWDCpwH7c,3867
+azpaddypy-0.1.7.dist-info/METADATA,sha256=-04_CkdsFyFSbUHzddoqbvL0S4cWx2BfLax8t48ueow,304
+azpaddypy-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+azpaddypy-0.1.7.dist-info/top_level.txt,sha256=wCjIwMZJaxbmRG_W4H2ZR9OmBJP3oKfhtvxrODAZqAo,19
+azpaddypy-0.1.7.dist-info/RECORD,,

azpaddypy-0.1.7.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mgmt
+test_function

mgmt/logging.py

@@ -3,6 +3,7 @@ import os
 import json
 import functools
 import time
+import asyncio
 from typing import Optional, Dict, Any, Union, List
 from datetime import datetime
 from azure.monitor.opentelemetry import configure_azure_monitor
@@ -317,7 +318,8 @@ class AzureLogger:
         log_execution: bool = True,
     ):
         """
-        Decorator to automatically trace function execution with comprehensive logging
+        Decorator to automatically trace function execution with comprehensive logging.
+        Supports both synchronous and asynchronous functions.
 
         Args:
             function_name: Custom name for the span (defaults to function name)
@@ -328,7 +330,7 @@ class AzureLogger:
 
         def decorator(func):
             @functools.wraps(func)
-            def wrapper(*args, **kwargs):
+            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:
@@ -336,6 +338,92 @@ class AzureLogger:
                     span.set_attribute("function.name", func.__name__)
                     span.set_attribute("function.module", func.__module__)
                     span.set_attribute("service.name", self.service_name)
+                    span.set_attribute("function.is_async", True)
+
+                    if self._correlation_id:
+                        span.set_attribute("correlation.id", self._correlation_id)
+
+                    if log_args and args:
+                        span.set_attribute("function.args_count", len(args))
+                    if log_args and kwargs:
+                        span.set_attribute("function.kwargs_count", len(kwargs))
+
+                    start_time = time.time()
+
+                    try:
+                        self.debug(
+                            f"Starting async function execution: {func.__name__}"
+                        )
+
+                        result = await func(*args, **kwargs)
+                        duration_ms = (time.time() - start_time) * 1000
+
+                        # Mark span as successful
+                        span.set_attribute("function.duration_ms", duration_ms)
+                        span.set_attribute("function.success", True)
+                        span.set_status(Status(StatusCode.OK))
+
+                        if log_result and result is not None:
+                            span.set_attribute("function.has_result", True)
+                            span.set_attribute(
+                                "function.result_type", type(result).__name__
+                            )
+
+                        if log_execution:
+                            self.log_function_execution(
+                                func.__name__,
+                                duration_ms,
+                                True,
+                                {
+                                    "args_count": len(args) if args else 0,
+                                    "kwargs_count": len(kwargs) if kwargs else 0,
+                                    "is_async": True,
+                                },
+                            )
+
+                        self.debug(
+                            f"Async function execution completed: {func.__name__}"
+                        )
+                        return result
+
+                    except Exception as e:
+                        duration_ms = (time.time() - start_time) * 1000
+
+                        # Mark span as failed
+                        span.set_status(Status(StatusCode.ERROR, str(e)))
+                        span.record_exception(e)
+                        span.set_attribute("function.duration_ms", duration_ms)
+                        span.set_attribute("function.success", False)
+                        span.set_attribute("error.type", type(e).__name__)
+                        span.set_attribute("error.message", str(e))
+
+                        if log_execution:
+                            self.log_function_execution(
+                                func.__name__,
+                                duration_ms,
+                                False,
+                                {
+                                    "error_type": type(e).__name__,
+                                    "error_message": str(e),
+                                    "is_async": True,
+                                },
+                            )
+
+                        self.error(
+                            f"Async function execution failed: {func.__name__} - {str(e)}"
+                        )
+                        raise
+
+            @functools.wraps(func)
+            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:
+                    # Add function metadata
+                    span.set_attribute("function.name", func.__name__)
+                    span.set_attribute("function.module", func.__module__)
+                    span.set_attribute("service.name", self.service_name)
+                    span.set_attribute("function.is_async", False)
 
                     if self._correlation_id:
                         span.set_attribute("correlation.id", self._correlation_id)
@@ -372,6 +460,7 @@ class AzureLogger:
                                 {
                                     "args_count": len(args) if args else 0,
                                     "kwargs_count": len(kwargs) if kwargs else 0,
+                                    "is_async": False,
                                 },
                             )
 
@@ -397,6 +486,7 @@ class AzureLogger:
                                 {
                                     "error_type": type(e).__name__,
                                     "error_message": str(e),
+                                    "is_async": False,
                                 },
                             )
 
@@ -405,7 +495,10 @@ class AzureLogger:
                         )
                         raise
 
-            return wrapper
+            # Return the appropriate wrapper based on whether the function is async
+            if asyncio.iscoroutinefunction(func):
+                return async_wrapper
+            return sync_wrapper
 
         return decorator
 

test_function/__init__.py

@@ -0,0 +1,112 @@
+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,
+        )

test_function/function_app.py

@@ -0,0 +1,129 @@
+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.1.5.dist-info/RECORD

@@ -1,7 +0,0 @@
-azpaddypy-0.1.5.dist-info/licenses/LICENSE,sha256=hQ6t0g2QaewGCQICHqTckBFbMVakGmoyTAzDpmEYV4c,1089
-mgmt/__init__.py,sha256=5-0eZuJMZlCONZNJ5hEvWXfvLIM36mg7FsEVs32bY_A,183
-mgmt/logging.py,sha256=jQ1jIkdSf7p44_oBJZD3rPodtwkhY5Y9rwRNafwXgcI,21061
-azpaddypy-0.1.5.dist-info/METADATA,sha256=aAN8735C6AhacUNVM36ZaUKW4wwq9onAMPROaJf5Oxo,298
-azpaddypy-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-azpaddypy-0.1.5.dist-info/top_level.txt,sha256=Xqg3gg53XEnWtdRarYe2ubJO0NDuer-pkr8RN2y7G-c,5
-azpaddypy-0.1.5.dist-info/RECORD,,

azpaddypy-0.1.5.dist-info/top_level.txt

@@ -1 +0,0 @@
-mgmt