Merge pull request #234044 from vmagelo/freshness-work4

v-regandowner · web-flow · commit d69c07823931 · 2023-04-27T13:30:45.000-04:00
Freshness work on memory profiler article.
diff --git a/articles/azure-functions/python-memory-profiler-reference.md b/articles/azure-functions/python-memory-profiler-reference.md
@@ -1,25 +1,25 @@
 ---
-title: Memory profiling on Python apps in Azure Functions
-description: Learn how to profile Python apps memory usage and identify memory bottleneck.
+title: Memory profiling of Python apps in Azure Functions
+description: Learn how to profile the memory usage of Python apps and identify memory bottleneck.
 ms.topic: how-to
-ms.date: 3/22/2021
+ms.date: 4/11/2023
 ms.devlang: python
 ms.custom: devx-track-python, py-fresh-zinc
 ---
 # Profile Python apps memory usage in Azure Functions
 
-During development or after deploying your local Python function app project to Azure, it's a good practice to analyze for potential memory bottlenecks in your functions. Such bottlenecks can decrease the performance of your functions and lead to errors. The following instruction show you how to use the [memory-profiler](https://pypi.org/project/memory-profiler) Python package, which provides line-by-line memory consumption analysis of your functions as they execute.
+During development or after deploying your local Python function app project to Azure, it's a good practice to analyze for potential memory bottlenecks in your functions. Such bottlenecks can decrease the performance of your functions and lead to errors. The following instructions show you how to use the [memory-profiler](https://pypi.org/project/memory-profiler) Python package, which provides line-by-line memory consumption analysis of your functions as they execute.
 
 > [!NOTE]
-> Memory profiling is intended only for memory footprint analysis on development environment. Please do not apply the memory profiler on production function apps.
+> Memory profiling is intended only for memory footprint analysis in development environments. Please do not apply the memory profiler on production function apps.
 
 ## Prerequisites
 
 Before you start developing a Python function app, you must meet these requirements:
 
-* [Python 3.6.x or above](https://www.python.org/downloads/release/python-374/). To check the full list of supported Python versions in Azure Functions, please visit [Python developer guide](functions-reference-python.md#python-version).
+* [Python 3.7 or above](https://www.python.org/downloads). To check the full list of supported Python versions in Azure Functions, see the [Python developer guide](functions-reference-python.md#python-version).
 
-* The [Azure Functions Core Tools](functions-run-local.md#v2) version 3.x.
+* The [Azure Functions Core Tools](functions-run-local.md#v2), version 4.x or greater. Check your version with `func --version`. To learn about updating, see [Azure Functions Core Tools on GitHub](https://github.com/Azure/azure-functions-core-tools).
 
 * [Visual Studio Code](https://code.visualstudio.com/) installed on one of the [supported platforms](https://code.visualstudio.com/docs/supporting/requirements#_platforms).
 
@@ -29,9 +29,9 @@ Before you start developing a Python function app, you must meet these requireme
 
 ## Memory profiling process
 
-1. In your requirements.txt, add `memory-profiler` to ensure the package will be bundled with your deployment. If you are developing on your local machine, you may want to [activate a Python virtual environment](create-first-function-cli-python.md#create-venv) and do a package resolution by `pip install -r requirements.txt`.
+1. In your requirements.txt, add `memory-profiler` to ensure the package is bundled with your deployment. If you're developing on your local machine, you may want to [activate a Python virtual environment](create-first-function-cli-python.md#create-venv) and do a package resolution by `pip install -r requirements.txt`.
 
-2. In your function script (usually \_\_init\_\_.py), add the following lines above the `main()` function. This will ensure the root logger reports the child logger names, so that the memory profiling logs are distinguishable by the prefix `memory_profiler_logs`.
+2. In your function script (for example, *\_\_init\_\_.py* for the Python v1 programming model and *function_app.py* for the v2 model), add the following lines above the `main()` function. These lines ensure the root logger reports the child logger names, so that the memory profiling logs are distinguishable by the prefix `memory_profiler_logs`.
 
     ```python
     import logging
@@ -40,51 +40,64 @@ Before you start developing a Python function app, you must meet these requireme
     root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
     profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)
 
-3. Apply the following decorator above any functions that need memory profiling. This does not work directly on the trigger entrypoint `main()` method. You need to create subfunctions and decorate them. Also, due to a memory-profiler known issue, when applying to an async coroutine, the coroutine return value will always be None.
+3. Apply the following decorator above any functions that need memory profiling. The decorator doesn't work directly on the trigger entrypoint `main()` method. You need to create subfunctions and decorate them. Also, due to a memory-profiler known issue, when applying to an async coroutine, the coroutine return value is always `None`.
 
     ```python
     @memory_profiler.profile(stream=profiler_logstream)
 
-4. Test the memory profiler on your local machine by using azure Functions Core Tools command `func host start`. This should generate a memory usage report with file name, line of code, memory usage, memory increment, and the line content in it.
+4. Test the memory profiler on your local machine by using Azure Functions Core Tools command `func host start`. When you invoke the functions, they should generate a memory usage report. The report contains file name, line of code, memory usage, memory increment, and the line content in it.
 
-5. To check the memory profiling logs on an existing function app instance in Azure, you can query the memory profiling logs in recent invocations by pasting the following Kusto queries in Application Insights, Logs.
+5. To check the memory profiling logs on an existing function app instance in Azure, you can query the memory profiling logs for recent invocations with [Kusto](/azure/azure-monitor/logs/log-query-overview) queries in Application Insights, Logs.
 
-:::image type="content" source="media/python-memory-profiler-reference/application-insights-query.png" alt-text="Query memory usage of a Python app in Application Insights":::
+    :::image type="content" source="media/python-memory-profiler-reference/application-insights-query.png" alt-text="Screenshot showing the query memory usage of a Python app in Application Insights.":::
 
-```text
-traces
-| where timestamp > ago(1d)
-| where message startswith_cs "memory_profiler_logs:"
-| parse message with "memory_profiler_logs: " LineNumber "  " TotalMem_MiB "  " IncreMem_MiB "  " Occurences "  " Contents
-| union (
+    ```kusto
     traces
     | where timestamp > ago(1d)
-    | where message startswith_cs "memory_profiler_logs: Filename: "
-    | parse message with "memory_profiler_logs: Filename: " FileName
-    | project timestamp, FileName, itemId
-)
-| project timestamp, LineNumber=iff(FileName != "", FileName, LineNumber), TotalMem_MiB, IncreMem_MiB, Occurences, Contents, RequestId=itemId
-| order by timestamp asc
-```
-
+    | where message startswith_cs "memory_profiler_logs:"
+    | parse message with "memory_profiler_logs: " LineNumber "  " TotalMem_MiB "  " IncreMem_MiB "  " Occurrences "  " Contents
+    | union (
+        traces
+        | where timestamp > ago(1d)
+        | where message startswith_cs "memory_profiler_logs: Filename: "
+        | parse message with "memory_profiler_logs: Filename: " FileName
+        | project timestamp, FileName, itemId
+    )
+    | project timestamp, LineNumber=iff(FileName != "", FileName, LineNumber), TotalMem_MiB, IncreMem_MiB, Occurrences, Contents, RequestId=itemId
+    | order by timestamp asc
+    ```
+    
 ## Example
 
-Here is an example of performing memory profiling on an asynchronous and a synchronous HTTP triggers, named "HttpTriggerAsync" and "HttpTriggerSync" respectively. We will build a Python function app that simply sends out GET requests to the Microsoft's home page.
+Here's an example of performing memory profiling on an asynchronous and a synchronous HTTP trigger, named "HttpTriggerAsync" and "HttpTriggerSync" respectively. We'll build a Python function app that simply sends out GET requests to the Microsoft's home page.
 
 ### Create a Python function app
 
 A Python function app should follow Azure Functions specified [folder structure](functions-reference-python.md#folder-structure). To scaffold the project, we recommend using the Azure Functions Core Tools by running the following commands:
 
+# [v1](#tab/v1)
+
 ```bash
 func init PythonMemoryProfilingDemo --python
 cd PythonMemoryProfilingDemo
 func new -l python -t HttpTrigger -n HttpTriggerAsync -a anonymous
 func new -l python -t HttpTrigger -n HttpTriggerSync -a anonymous
 ```
 
+# [v2](#tab/v2)
+
+```bash
+func init PythonMemoryProfilingDemov2 --python -m v2
+cd PythonMemoryProfilingDemov2
+```
+
+For the Python V2 programming model, triggers and bindings are created as decorators within the Python file itself, the *function_app.py* file. For information on how to create a new function with the new programming model, see the [Azure Functions Python developer guide](https://aka.ms/pythonprogrammingmodel). `func new` isn't supported for the preview of the V2 Python programming model.
+
+---
+
 ### Update file contents
 
-The requirements.txt defines the packages that will be used in our project. Besides the Azure Functions SDK and memory-profiler, we introduce `aiohttp` for asynchronous HTTP requests and `requests` for synchronous HTTP calls.
+The *requirements.txt* defines the packages that are used in our project. Besides the Azure Functions SDK and memory-profiler, we introduce `aiohttp` for asynchronous HTTP requests and `requests` for synchronous HTTP calls.
 
 ```text
 # requirements.txt
@@ -95,7 +108,11 @@ aiohttp
 requests
 ```
 
-We also need to rewrite the asynchronous HTTP trigger `HttpTriggerAsync/__init__.py` and configure the memory profiler, root logger format, and logger streaming binding.
+Create the asynchronous HTTP trigger.
+
+# [v1](#tab/v1)
+
+Replace the code in the asynchronous HTTP trigger *HttpTriggerAsync/\_\_init\_\_.py* with the following code, which configures the memory profiler, root logger format, and logger streaming binding.
 
 ```python
 # HttpTriggerAsync/__init__.py
@@ -114,7 +131,7 @@ profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)
 async def main(req: func.HttpRequest) -> func.HttpResponse:
     await get_microsoft_page_async('https://microsoft.com')
     return func.HttpResponse(
-        f"Microsoft Page Is Loaded",
+        f"Microsoft page loaded.",
         status_code=200
     )
 
@@ -128,7 +145,49 @@ async def get_microsoft_page_async(url: str):
     # GitHub Issue: https://github.com/pythonprofilers/memory_profiler/issues/289
 ```
 
-For synchronous HTTP trigger, please refer to the following `HttpTriggerSync/__init__.py` code section:
+# [v2](#tab/v2)
+
+Replace the code in the *function_app.py* file with the following code, which configures the memory profiler, root logger format, and logger streaming binding.
+
+```python
+# function_app.py
+import azure.functions as func
+import logging
+import aiohttp
+import requests
+import memory_profiler
+
+app = func.FunctionApp()
+
+# Update root logger's format to include the logger name. Ensure logs generated
+# from memory profiler can be filtered by "memory_profiler_logs" prefix.
+root_logger = logging.getLogger()
+root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
+profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)
+
+@app.function_name(name="HttpTriggerAsync")
+@app.route(route="HttpTriggerAsync", auth_level=func.AuthLevel.ANONYMOUS)
+async def test_function(req: func.HttpRequest) -> func.HttpResponse:
+    await get_microsoft_page_async('https://microsoft.com')
+    return func.HttpResponse(f"Microsoft page loaded.")
+
+@memory_profiler.profile(stream=profiler_logstream)
+async def get_microsoft_page_async(url: str):
+    async with aiohttp.ClientSession() as client:
+        async with client.get(url) as response:
+            await response.text()
+    # @memory_profiler.profile does not support return for coroutines.
+    # All returns become None in the parent functions.
+    # GitHub Issue: https://github.com/pythonprofilers/memory_profiler/issues/289
+```
+
+---
+
+Create the synchronous HTTP trigger.
+
+# [v1](#tab/v1)
+
+Replace the code in the asynchronous HTTP trigger *HttpTriggerSync/\_\_init\_\_.py* with the following code.
 
 ```python
 # HttpTriggerSync/__init__.py
@@ -147,7 +206,7 @@ profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)
 def main(req: func.HttpRequest) -> func.HttpResponse:
     content = profile_get_request('https://microsoft.com')
     return func.HttpResponse(
-        f"Microsoft Page Response Size: {len(content)}",
+        f"Microsoft page response size: {len(content)}",
         status_code=200
     )
 
@@ -157,21 +216,40 @@ def profile_get_request(url: str):
     return response.content
 ```
 
+# [v2](#tab/v2)
+
+Add this code to the bottom of the existing *function_app.py* file.
+
+```python
+@app.function_name(name="HttpTriggerSync")
+@app.route(route="HttpTriggerSync", auth_level=func.AuthLevel.ANONYMOUS)
+def test_function(req: func.HttpRequest) -> func.HttpResponse:
+    content = profile_get_request('https://microsoft.com')
+    return func.HttpResponse(f"Microsoft Page Response Size: {len(content)}")
+
+@memory_profiler.profile(stream=profiler_logstream)
+def profile_get_request(url: str):
+    response = requests.get(url)
+    return response.content
+```
+
+---
+
 ### Profile Python function app in local development environment
 
-After making all the above changes, there are a few more steps to initialize a Python virtual envionment for Azure Functions runtime.
+After you make the above changes, there are a few more steps to initialize a Python virtual environment for Azure Functions runtime.
 
 1. Open a Windows PowerShell or any Linux shell as you prefer.
 2. Create a Python virtual environment by `py -m venv .venv` in Windows, or `python3 -m venv .venv` in Linux.
-3. Activate the Python virutal environment with `.venv\Scripts\Activate.ps1` in Windows PowerShell or `source .venv/bin/activate` in Linux shell.
-4. Restore the Python dependencies with `pip install requirements.txt`
+3. Activate the Python virtual environment with `.venv\Scripts\Activate.ps1` in Windows PowerShell or `source .venv/bin/activate` in Linux shell.
+4. Restore the Python dependencies with `pip install -r requirements.txt`
 5. Start the Azure Functions runtime locally with Azure Functions Core Tools `func host start`
 6. Send a GET request to `https://localhost:7071/api/HttpTriggerAsync` or `https://localhost:7071/api/HttpTriggerSync`.
-7. It should show a memory profiling report similiar to below section in Azure Functions Core Tools.
+7. It should show a memory profiling report similar to the following section in Azure Functions Core Tools.
 
     ```text
     Filename: <ProjectRoot>\HttpTriggerAsync\__init__.py
-    Line #    Mem usage    Increment  Occurences   Line Contents
+    Line #    Mem usage    Increment  Occurrences   Line Contents
     ============================================================
         19     45.1 MiB     45.1 MiB           1   @memory_profiler.profile
         20                                         async def get_microsoft_page_async(url: str):
