Final rewrites + Acrolinx

Author: ggailey777

articles/azure-functions/flex-consumption-how-to.md

@@ -133,7 +133,7 @@ To support your function code, you need to create three resources:
     This command creates a function app running in the Flex Consumption plan. 
 
     Because you created the app without specifying [always ready instances](#set-always-ready-instance-counts), your app only incurs costs when actively executing functions. The command also creates an associated Azure Application Insights instance in the same resource group, with which you can monitor your function app and view logs. For more information, see [Monitor Azure Functions](functions-monitoring.md).
-    ```
+
 
 ### [Azure portal](#tab/azure-portal)
 
@@ -183,7 +183,7 @@ You can use the Azure CLI to upload a deployment package file to the deployment
 This package file must contain all of the build output files and referenced libraries required for your project to run. 
 ::: zone-end
 ::: zone pivot="programming-language-javascript,programming-language-typescript"
-For projects with a large amount of libraries, you should package the root of your project file and request a [remote build]. 
+For projects with a large number of libraries, you should package the root of your project file and request a [remote build]. 
 ::: zone-end
 ::: zone pivot="programming-language-python"
 For Python projects, you should package the root of your project file and always request a [remote build]. Using a remote build prevents potential issues that can occur when you build a project on Windows to be deployed on Linux.  
@@ -274,7 +274,7 @@ For Python projects, you should package the root of your project file and always
 
 ### [Continuous Deployment](#tab/continuous-deployment)
 
-Azure Functions has a custom GitHub Action and Azure DevOps Task to support continuous deployment. Refer the following guides to incorporate these tools in your CI/CD pipelines:
+Azure Functions has both a custom GitHub Action and a custom Azure Piplines Task to support continuous deployment. Refer the following guides to incorporate these tools in your CI/CD pipelines:
 
 - [Build and deploy using Azure Pipelines](./functions-how-to-azure-devops.md)
 - [Build and deploy using GitHub Actions](./functions-how-to-github-actions.md)
@@ -412,7 +412,7 @@ az functionapp vnet-integration list --resource-group <RESOURCE_GROUP> --name <A
 
 You can integrate your existing app with an existing virtual network and subnet in the portal. 
 
-1. In your function app page in the [Azure portal](https://portal.azure.com), expand **Settings** in the left menu and select **Networking**.
+1. In your function app page in the [Azure portal], expand **Settings** in the left menu and select **Networking**.
 
 1. Under **Outbound traffic configuration**, select **Not configured**.
 
@@ -493,7 +493,7 @@ az functionapp deployment config set --resource-group <RESOURCE_GROUP> --name <A
 
 ### [Azure portal](#tab/azure-portal)
 
-1. In your function app page in the [Azure portal](https://portal.azure.com), expand **Settings** in the left menu and select **Deployment settings**.
+1. In your function app page in the [Azure portal], expand **Settings** in the left menu and select **Deployment settings**.
 
 1. Under Application package location, select an existing **Storage account** and then select an existing empty **container** in the account.
 
@@ -548,7 +548,7 @@ az functionapp scale config set --resource-group <resourceGroup> --name <APP_NAM
 
 ### [Azure portal](#tab/azure-portal)
 
-1. In your function app page in the [Azure portal](https://portal.azure.com), expand **Settings** in the left menu and select **Scale and concurrency**.
+1. In your function app page in the [Azure portal], expand **Settings** in the left menu and select **Scale and concurrency**.
 
 1. Select an **Instance memory** option and select **Save** to update the app.
 
@@ -612,7 +612,7 @@ az functionapp scale config always-ready delete --resource-group <RESOURCE_GROUP
 
 ### [Azure portal](#tab/azure-portal)
 
-1. In your function app page in the [Azure portal](https://portal.azure.com), expand **Settings** in the left menu and select **Scale and concurrency**.
+1. In your function app page in the [Azure portal], expand **Settings** in the left menu and select **Scale and concurrency**.
 
 1. Under **Always-ready instance minimum** type `http`, `blob`, `durable`, or a specific function name using the format `function:<FUNCTION_NAME>=n` in **Trigger** and type the **Number of always-ready instances**.
 
@@ -642,7 +642,7 @@ This example sets the HTTP trigger concurrency level to `10`. After you specific
 
 ### [Azure portal](#tab/azure-portal)
 
-1. In your function app page in the [Azure portal](https://portal.azure.com), expand **Settings** in the left menu and select **Scale and concurrency**.
+1. In your function app page in the [Azure portal], expand **Settings** in the left menu and select **Scale and concurrency**.
 
 1. Under **Concurrency per instance** select **Assign manually** and type a specific limit.
 
@@ -662,65 +662,93 @@ To view the list of regions that currently support Flex Consumption plans:
 
 When you create an app in the [Azure portal](flex-consumption-how-to.md?tabs=azure-portal#create-a-flex-consumption-app) or by using [Visual Studio Code](flex-consumption-how-to.md?tabs=vs-code#create-a-flex-consumption-app), currently unsupported regions are filtered out of the region list.
 
-## Configure monitoring
+## Monitor your app in Azure
+
+Azure Monitor provides these distinct sets of metrics to help you better understand how your function app runs in Azure:
+
++ Platform metrics: provides infrastructure-level insights
++ Application Insights: provides code-level insights, including traces and errors logs.
+
+If you haven't done so already, you should [enable Application Insights in your app](configure-monitoring.md#enable-application-insights-integration) to be able to:
+
++ Track detailed execution times and dependencies
++ Monitor individual function performance
++ Analyze failures and exceptions
++ Correlate platform metrics with application behavior with custom queries
+
+For more information, see [Monitor Azure Functions](monitor-functions.md).
+
+### Supported metrics
+
+Run this script to view all of the platform metrics that are currently available your app:
+
+```azurecli
+appId=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query id -o tsv)
+az monitor metrics list-definitions --resource $appId --query "[].{Name:name.localizedValue,Value:name.value}" -o table
+```
+
+In this example, replace `<RESOURCE_GROUP>` and `<APP_NAME>` with your resource group and function app names, respectively. This script gets the fully qualified app ID and returns the available platform metrics in a table.
+
+### View metrics
+
+You can review current metrics either in the Azure portal or by using the Azure CLI. 
 
-The following metrics are specifically available for Flex Consumption apps:
+In the Azure portal, you can also create metrics alerts and pin charts and other reports to dashboards in the portal.
 
-##### [Azure CLI](#tab/azure-cli)
+### [Azure CLI](#tab/azure-cli)
+
+Use this script to generate a report of the current metrics for your app: 
 
 ```azurecli
-# First, get the resource ID of your Flex Consumption function app (required for metrics commands)
-ResourceId=$(az functionapp show --name <FunctionAppName> --resource-group <ResourceGroupName> --query id -o tsv)
-echo "Function App Resource ID: $ResourceId"
+appId=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query id -o tsv)
+
+appId=$(az functionapp show --name func-fuxigh6c255de --resource-group exampleRG --query id -o tsv)
 
-# Monitor Always Ready and On Demand execution counts
-az monitor metrics list --resource $ResourceId --metric "AlwaysReadyFunctionExecutionCount" --interval PT1H --output table
-az monitor metrics list --resource $ResourceId --metric "OnDemandFunctionExecutionCount" --interval PT1H --output table
+echo -e "\nAlways-ready and on-emand execution counts..."
+az monitor metrics list --resource $appId --metric "AlwaysReadyFunctionExecutionCount" --interval PT1H --output table
+az monitor metrics list --resource $appId --metric "OnDemandFunctionExecutionCount" --interval PT1H --output table
 
-# Monitor execution units (MB-milliseconds) in Always Ready and On Demand instances
-az monitor metrics list --resource $ResourceId --metric "AlwaysReadyFunctionExecutionUnits" --interval PT1H --output table
-az monitor metrics list --resource $ResourceId --metric "OnDemandFunctionExecutionUnits" --interval PT1H --output table
+echo -e "\nExecution units (MB-ms) in always-ready and on-emand execution counts..."
+az monitor metrics list --resource $appId --metric "AlwaysReadyFunctionExecutionUnits" --interval PT1H --output table
+az monitor metrics list --resource $appId --metric "OnDemandFunctionExecutionUnits" --interval PT1H --output table
 
-# Monitor Always Ready resource utilization
-az monitor metrics list --resource $ResourceId --metric "AlwaysReadyUnits" --interval PT1H --output table
+echo -e "\nAlways-ready resource utilization..."
+az monitor metrics list --resource $appId --metric "AlwaysReadyUnits" --interval PT1H --output table
 
-# Monitor memory utilization
-az monitor metrics list --resource <ResourceId> --metric "AverageMemoryWorkingSet" --interval PT1H --output table
-az monitor metrics list --resource <ResourceId> --metric "MemoryWorkingSet" --interval PT1H --output table
+echo -e "\nMemory utilization..."
+az monitor metrics list --resource $appId --metric "AverageMemoryWorkingSet" --interval PT1H --output table
+az monitor metrics list --resource $appId --metric "MemoryWorkingSet" --interval PT1H --output table
 
-# Monitor instance count and CPU utilization
-az monitor metrics list --resource <ResourceId> --metric "InstanceCount" --interval PT1H --output table
-az monitor metrics list --resource <ResourceId> --metric "CpuPercentage" --interval PT1H --output table
+echo -e "\nInstance count and CPU utilization..."
+az monitor metrics list --resource $appId --metric "InstanceCount" --interval PT1H --output table
+az monitor metrics list --resource $appId --metric "CpuPercentage" --interval PT1H --output table
 ```
 
+### [Azure portal](#tab/azure-portal)
+
+1. In your function app page in the [Azure portal], select **Monitoring** > **Metrics** and if the current chart is blank, select **+ Add metric**.
+
+1. With your app as the **Scope**, choose one or more of the supported **Metric** options to add to the current chart.
+
+1. Repeat the previous step to add other metrics to the chart.
+
+1. (Optional) Select **Save to dashboard** to add the current chart to a new or existing dashboard. Remember to include both always-ready and on-demand metrics for broad visibility. 
+
+1. (Optional) Select **New alert rue** to create an alert on a specific metric. Remember to include both always-ready and on-demand metrics for broad visibility. 
 
-##### [Azure portal](#tab/azure-portal)
-
-1. **Function App Metrics**:
-   + Navigate to your Flex Consumption function app in Azure Portal
-   + Go to "Metrics" under the "Monitoring" section
-   + Click "Add metric" and explore the available metrics:
-     + **Always Ready metrics**: Always Ready Function Execution Count, Always Ready Function Execution Units, Always Ready Units
-     + **On Demand metrics**: On Demand Function Execution Count, On Demand Function Execution Units
-     + **Memory metrics**: Average Memory Working Set, Memory Working Set
-     + **Performance metrics**: Instance Count, Cpu Percentage
-   + Create custom charts combining related metrics for better visibility
-   + Use "Add filter" to focus on specific functions or dimensions
-
-2. **Custom Monitoring Dashboards**:
-   + Create a dedicated dashboard for monitoring your Flex Consumption app
-   + Add multiple metric charts to track different aspects of performance
-   + Include both Always Ready and On Demand metrics for complete visibility
-   + Set up alerts for key metrics that exceed expected thresholds
-
-3. **Application Insights Integration (Recommended)**:
-   + While platform metrics provide infrastructure-level insights, Application Insights gives you code-level visibility
-   + If not already enabled, add Application Insights to your function app
-   + Within Application Insights, you can:
-     + Track detailed execution times and dependencies
-     + Monitor individual function performance
-     + Analyze failures and exceptions
-     + Create custom queries to correlate platform metrics with application behavior
+### [Visual Studio Code](#tab/vs-code)
+
+You can't currently review and set metrics using Visual Studio Code. 
+
+---
+
+To learn more about metrics for Azure Functions, see [Monitor Azure Functions](monitor-functions.md).
+
+### View logs
+
+When your app is connected to Application Insights, you can better analyze your app performance and troubleshoot problems during execution.
+
+ 
    + Use "Performance" to analyze response times and dependencies
    + Use "Failures" to identify any errors occurring after migration
    + Create custom queries in "Logs" to analyze function behavior:
@@ -732,11 +760,29 @@ az monitor metrics list --resource <ResourceId> --metric "CpuPercentage" --inter
      | summarize successCount=countif(success == true), failureCount=countif(success == false) by bin(timestamp, 1h), cloud_RoleName
      | render timechart
      ```
-### [Visual Studio Code](#tab/vs-code)
 
-You can't currently review and set metrics using Visual Studio Code. 
+### View costs
 
----
+Because you can tune your app to adjust performance versus operating costs, it's important to track the costs associated with running your app in the Flex Consumption plan. 
+
+To view the current costs:
+
+1. In your function app page in the [Azure portal], select the resource group link.
+
+1. In the resource group page, select **Cost Management** > **Cost analysis**.
+
+1. Review the current costs and cost trajectory of the app itself. 
+
+1. Optionally, select **Cost Management** > **Alerts** and then **+ Add** to create a new alert for the app.
+
+## Fine-tune your app
+
+The Flex Consumption plan provides several settings that you can tune to refine the performance of your app. Actual performance and costs can vary based on your app-specific workload patterns and configuration. For example, higher [memory instance sizes](./flex-consumption-plan.md#instance-memory) can improve performance for memory-intensive operations but at a higher cost per active period. 
+
+Here are some adjustments you can make to fine-tune performance versus cost:
+ 
++ [Adjust concurrency settings](./functions-concurrency.md) to maximize throughput per instance. 
++ [Choose the appropriate memory size](#configure-instance-memory) for your workload. Higher memory sizes cost more but can improve performance.
 
 ## Related content
 
@@ -745,3 +791,5 @@ You can't currently review and set metrics using Visual Studio Code.
 
 [`az functionapp create`]: /cli/azure/functionapp#az-functionapp-create
 [remote build]: ./functions-deployment-technologies.md#remote-build
+[Azure portal]: https://portal.azure.com
+

articles/azure-functions/flex-consumption-plan.md

@@ -20,12 +20,13 @@ You can review end-to-end samples that feature the Flex Consumption plan in the
 
 ## Benefits
 
-The Flex Consumption plan builds on the strengths of the Consumption plan, which include dynamic scaling and execution-based billing. With Flex Consumption, you also get these extra features:
+The Flex Consumption plan builds on the strengths of the serverless Consumption plan, which include dynamic scaling and execution-based billing. With Flex Consumption, you also get these extra features:
 
-+ [Always-ready instances](#always-ready-instances) 
-+ [Virtual network integration](#virtual-network-integration)
-+ Fast scaling based on concurrency for both HTTP and non-HTTP apps
-+ Multiple choices for instance memory sizes
++ **Reduced Cold Start Times**: Enable [always-ready instances](#always-ready-instances) to achieve faster cold-start times compared to the Consumption plan. 
++ **Virtual network support**: [Virtual network integration](#virtual-network-integration) enables your serverless app to run in a virtual network.
++ **Per-Function Scaling**: Each function in your app [scales independently based on its workload](#per-function-scaling), potentially resulting in more efficient resource allocation.
++ **Improved Concurrency Handling**: Better handling of concurrent executions with configurable concurrency settings per function.
++ **Flexible Memory Configuration**: Flex Consumption offers multiple [instance memory](#instance-memory) size options, allowing you to optimize for your specific workload requirements.
 
 This table helps you directly compare the features of Flex Consumption with the Consumption hosting plan:
 
@@ -123,18 +124,18 @@ This table shows the language stack versions that are currently supported for Fl
 
 Currently, each region in a given subscription has a memory limit of `512,000 MB` for all instances of apps running on Flex Consumption plans. This quota means that, in a given subscription and region, you could have any combination of instance memory sizes and counts, as long as they stay under the quota limit. For example, each the following examples would mean the quota is reached and the apps would stop scaling:
 
-+ You have one 512 MB app scaled to 250 instances and a second 512 MB app scaled to 750 instances. 
-+ You have one 512 MB app scaled to 1,000 instances.
-+ You have one 2,048 MB app scaled to 100 and a second 2,048 MB app scaled to 150 instances
-+ You have one 2,048 MB app that scaled out to 250 instances
-+ You have one 4,096 MB app that scaled out to 125 instances
-+ You have one 4,096 MB app scaled to 100 and one 2,048 MB app scaled to 50 instances
++ You have one 512-MB app scaled to 250 instances and a second 512-MB app scaled to 750 instances. 
++ You have one 512-MB app scaled to 1,000 instances.
++ You have one 2,048-MB app scaled to 100 and a second 2,048-MB app scaled to 150 instances
++ You have one 2,048-MB app that scaled out to 250 instances
++ You have one 4,096-MB app that scaled out to 125 instances
++ You have one 4,096-MB app scaled to 100 and one 2,048-MB app scaled to 50 instances
 
 Flex Consumption apps scaled to zero, or instances marked to be scaled in and deleted, don't count against the quota. This quota can be increased to allow your Flex Consumption apps to scale further, depending on your requirements. If your apps require a larger quota, create a support ticket.
 
 ## Deprecated properties and settings
 
-In Flex Consumption many of the standard application settings and site configuration properties are deprecated or have moved and shouldn't be used when automating function app resource creation. For more information, see [Flex Consumption plan deprecations](functions-app-settings.md#flex-consumption-plan-deprecations).
+In the Flex Consumption plan, many of the standard application settings and site configuration properties are deprecated or have moved and shouldn't be used when automating function app resource creation. For more information, see [Flex Consumption plan deprecations](functions-app-settings.md#flex-consumption-plan-deprecations).
 
 ## Considerations