Merge pull request #310965 from MicrosoftDocs/main

Auto Publish – main to live - 2026-01-27 23:00 UTC

Author: learn-build-service-prod[bot]

articles/azure-app-configuration/feature-management-python-reference.md

@@ -425,7 +425,8 @@ This strategy for rolling out a feature is built into the library through the in
 
 ### Targeting a user
 
-Either a user can be specified directly in the `is_enabled` call or a `TargetingContext` can be used to specify the user and optional group.
+A user can either be specified directly in the `is_enabled` call,  or a `TargetingContext` can be used to specify the user and optional group. The `TargetingContext` can either be passed in when calling `is_enabled` or by providing a callback to `targeting_context_accessor` when creating the `FeatureManager`.
+
 
 ```python
 # Directly specifying the user
@@ -435,6 +436,26 @@ result = is_enabled(feature_flags, "test_user")
 result = is_enabled(feature_flags, TargetingContext(user_id="test_user", groups=["Ring1"]))
 ```
 
+#### Targeting context accessor
+
+Instead of passing a `TargetingContext` to each `is_enabled` call, you can register a callback function with the `FeatureManager` that automatically provides the targeting context. This approach is useful when the user identity and groups can be determined from a common source, such as HTTP request headers or session data, eliminating the need to manually construct and pass the context for every feature evaluation.
+
+```python
+from quart import request
+from featuremanagement import FeatureManager, TargetingContext
+
+# A callback for assigning a TargetingContext for Feature Flag evaluation in a Quart app
+def my_targeting_accessor() -> TargetingContext:
+    session_id = ""
+    if "Session-ID" in request.headers:
+        session_id = request.headers["Session-ID"]
+    return TargetingContext(user_id=session_id)
+
+
+# Load feature flags and set up targeting context accessor
+feature_manager = FeatureManager(config, targeting_context_accessor=my_targeting_accessor)
+```
+
 ### Targeting exclusion
 
 When defining an audience, users and groups can be excluded from the audience. Exclusions are useful for when a feature is being rolled out to a group of users, but a few users or groups need to be excluded from the rollout. Exclusion is defined by adding a list of users and groups to the `Exclusion` property of the audience.
@@ -735,7 +756,11 @@ configure_azure_monitor(
     )
 ```
 
-### Custom telemetry publishing
+### Logging telemetry events
+
+The feature management library provides multiple ways to log telemetry events. You can use the built-in callback for feature flag evaluation events or manually track custom events for user interactions and application events.
+
+#### Feature evaluation events
 
 Because the telemetry callback is a function, it can be customized to publish telemetry to any desired destination. For example, telemetry could be published to a logging service, a database, or a custom telemetry service.
 
@@ -749,6 +774,61 @@ When a feature flag is evaluated and telemetry is enabled, the feature manager c
 | `Variant` | The assigned variant. |
 | `VariantAssignmentReason` | The reason why the variant is assigned. |
 
+#### Tracking custom events
+
+Beyond automatic feature flag evaluation telemetry, you can manually track custom events using the `track_event` function. This is useful for tracking user interactions, business events, or other custom telemetry that should be correlated with feature flag usage.
+
+```python
+from featuremanagement.azuremonitor import track_event
+
+# Track a custom event with a user identifier
+track_event("ButtonClicked", "user123")
+
+# Track an event without a user identifier
+track_event("ApplicationStarted")
+```
+
+The `track_event` function accepts two parameters:
+
+| Parameter | Description |
+| ---------------- | ---------------- |
+| `event_name` | The name of the event to track. |
+| `user` | Optional user identifier to associate with the event. |
+
+Custom events are sent to the same Application Insights instance configured for feature flag telemetry, allowing you to correlate feature flag evaluations with user behavior and application events.
+
+### Enriching telemetry with targeting context
+
+Instead of manually passing user identifiers to each `track_event` call, you can use the `TargetingSpanProcessor` to automatically enrich all telemetry with targeting context information. The processor accepts a callback function that returns a `TargetingContext`, allowing telemetry to automatically include the user ID for each request. This enrichment helps correlate telemetry data with specific users and groups, making it easier to analyze feature flag performance for targeted audiences without requiring explicit user parameters in your telemetry calls.
+
+> [!NOTE]
+> The `TargetingSpanProcessor` is specifically for telemetry enrichment. You still need to provide a `targeting_context_accessor` to the `FeatureManager` for feature flag evaluation, as described in the [Targeting context accessor](#targeting-context-accessor) section.
+
+The following example demonstrates how to configure the processor in a Quart application, using a session ID from request headers as the user identifier. Call `configure_azure_monitor` before creating your application instance to ensure proper initialization.
+
+```python
+import os
+from quart import request
+from azure.monitor.opentelemetry import configure_azure_monitor
+from featuremanagement import TargetingContext
+from featuremanagement.azuremonitor import TargetingSpanProcessor
+
+async def my_targeting_accessor() -> TargetingContext:
+    session_id = ""
+    if "Session-ID" in request.headers:
+        session_id = request.headers["Session-ID"]
+    return TargetingContext(user_id=session_id)
+
+# Configure Azure Monitor with targeting context for telemetry
+configure_azure_monitor(
+    connection_string=os.getenv("APPLICATIONINSIGHTS_CONNECTION_STRING"),
+    span_processors=[TargetingSpanProcessor(targeting_context_accessor=my_targeting_accessor)],
+)
+
+# You must also provide the targeting context accessor to FeatureManager for evaluation
+feature_manager = FeatureManager(config, targeting_context_accessor=my_targeting_accessor)
+```
+
 ## Next steps
 
 To learn how to use feature flags in your applications, continue to the following quickstarts.

articles/azure-functions/breadcrumb/toc.yml

@@ -4,5 +4,11 @@ items:
   topicHref: /azure/index
   items:
   - name: Azure Functions
-    tocHref: /azure/azure-functions
+    tocHref: /azure/azure-functions/
+    topicHref: /azure/azure-functions/index
+  - name: Azure Functions
+    tocHref: /azure/developer/
+    topicHref: /azure/azure-functions/index
+  - name: Azure Functions
+    tocHref: /azure/reliability/
     topicHref: /azure/azure-functions/index

articles/azure-resource-manager/bicep/data-types.md

@@ -2,7 +2,7 @@
 title: Data types in Bicep
 description: This article describes the data types that are available in Bicep.
 ms.topic: reference
-ms.date: 01/02/2026
+ms.date: 01/27/2026
 ms.custom: devx-track-bicep
 ---
 
@@ -355,14 +355,11 @@ var storageName = 'storage${uniqueString(resourceGroup().id)}'
 
 ### Multi-line strings
 
-In Bicep, multi-line strings are defined between three single quotation marks (`'''`) followed optionally by a newline (the opening sequence) and three single quotation marks (`'''` is the closing sequence). Characters that are entered between the opening and closing sequence are read verbatim. Escaping isn't necessary or possible.
+## Multi-line strings
 
-> [!NOTE]
-> The Bicep parser reads every character as it is. Depending on the line endings of your Bicep file, newlines are interpreted as either `\r\n` or `\n`.
->
-> Interpolation isn't currently supported in multi-line strings. Because of this limitation, you might need to use the [`concat`](./bicep-functions-string.md#concat) function instead of using [interpolation](#strings).
->
-> Multi-line strings that contain `'''` aren't supported.
+You can define a multi-line string by enclosing it in three single quotation marks (`'''`). The string content is preserved exactly as written, so escape characters are not required. The delimiter `'''` cannot appear within the string.
+
+The string may begin immediately after the opening delimiter or on the following line. In both cases, the resulting value does not include a leading newline. Line breaks are interpreted as `\r\n` or `\n`, depending on the line-ending format of the Bicep file.
 
 ```bicep
 // evaluates to "hello!"
@@ -389,11 +386,26 @@ var myVar5 = '''
 comments // are included
 /* because everything is read as-is */
 '''
+```
+
+With Bicep CLI version v0.40.2 or higher, string interpolation is supported. An optional `$` prefix can be added before the opening delimiter to enable string interpolation using standard Bicep `${...}` syntax. If you need to include `${...}` as a literal value without escaping, you can control interpolation by repeating the `$` prefix. Interpolation is only performed when the number of `$` characters preceding `${...}` matches the number of `$` characters used in the opening delimiter.
 
+```bicep
 // evaluates to "interpolation\nis ${blocked}"
 // note ${blocked} is part of the string, and is not evaluated as an expression
 var myVar6 = '''interpolation
 is ${blocked}'''
+
+// evaluates to "this is a test"
+var interpolated = 'a test'
+var myVar7 = $'''
+this is ${interpolated}'''
+
+// evaluates to "this is a test\nthis is not ${interpolated}"
+var interpolated = 'a test'
+var myVar8 = $$'''
+this is $${interpolated}
+this is not ${interpolated}'''
 ```
 
 ### String-related operators

articles/azure-resource-manager/bicep/file.md

@@ -3,7 +3,7 @@ title: Bicep file structure and syntax
 description: Understand how to use declarative syntax to understand the structure and properties of Bicep files.
 ms.topic: article
 ms.custom: devx-track-bicep
-ms.date: 07/25/2025
+ms.date: 01/13/2026
 ---
 
 # Bicep file structure and syntax
@@ -464,32 +464,6 @@ The following example shows a multiline comment.
 param existingKeyVaultName string
 ```
 
-## Multi-line strings
-
-You can break a string into multiple lines. Use three single quotation marks `'''` to start and end the multi-line string.
-
-Characters within the multi-line string are handled as is. Escape characters are unnecessary. You can't include `'''` in the multi-line string. String interpolation isn't currently supported.
-
-You can start your string right after the opening `'''`, or include a new line. In either case, the resulting string doesn't include a new line. Depending on the line endings in your Bicep file, new lines are interpreted as `\r\n` or `\n`.
-
-The following example shows a multi-line string.
-
-```bicep
-var stringVar = '''
-this is multi-line
-  string with formatting
-  preserved.
-'''
-```
-
-The preceding example is equivalent to the following JSON:
-
-```json
-"variables": {
-  "stringVar": "this is multi-line\r\n  string with formatting\r\n  preserved.\r\n"
-}
-```
-
 ## Multiple-line declarations
 
 You can now use multiple lines in function, array, and object declarations. This feature requires [Bicep CLI version 0.7.X or higher](./install.md).

articles/azure-resource-manager/templates/syntax.md

@@ -3,7 +3,7 @@ title: Template structure and syntax
 description: Describes the structure and properties of Azure Resource Manager templates (ARM templates) using declarative JSON syntax.
 ms.topic: article
 ms.custom: devx-track-arm-template
-ms.date: 04/28/2025
+ms.date: 01/13/2026
 ---
 
 # Understand the structure and syntax of ARM templates
@@ -497,7 +497,7 @@ You can break a string into multiple lines. For example, see the `location` prop
   ],
 ```
 
-In Bicep, see [multi-line strings](../bicep/file.md#multi-line-strings).
+In Bicep, see [multi-line strings](../bicep/data-types.md#multi-line-strings).
 
 ## languageVersion 2.0
 

articles/azure-vmware/includes/vmware-software-versions.md

@@ -23,7 +23,7 @@ The following table lists the software versions that are used in new deployments
 | VMware vSAN on-disk format       |    [20](https://knowledge.broadcom.com/external/article?legacyId=2148493) | N/A |
 | VMware vSAN storage architecture |    [Gen 1: OSA, Gen2: ESA](https://blogs.vmware.com/cloud-foundation/2022/08/31/comparing-the-original-storage-architecture-to-the-vsan-8-express-storage-architecture/) | N/A |
 | VMware NSX                       |    [!INCLUDE [nsxt-version](nsxt-version.md)] | 22224317 |
-| VMware HCX                       |    [4.11.1](https://techdocs.broadcom.com/us/en/vmware-cis/hcx/vmware-hcx/4-11/hcx-4-11-release-notes/vmware-hcx-4111-release-notes.html) | 24846706 |
+| VMware HCX                       |    [4.11.3](https://techdocs.broadcom.com/us/en/vmware-cis/hcx/vmware-hcx/4-11/hcx-4-11-release-notes/vmware-hcx-4113-release-notes.html) | 24972695 |
 | VMware Live Site Recovery        |    [9.0.2.1](https://techdocs.broadcom.com/us/en/vmware-cis/live-recovery/live-site-recovery/9-0/release-notes/id-b55981c1-41e6-4ad3-b379-ce565212add3.html) | 24401761 |
 | VMware vSphere Replication       |    [9.0.2.1](https://techdocs.broadcom.com/us/en/vmware-cis/live-recovery/vsphere-replication/9-0/release-notes/vsphere-replication-9021-release-notes.html) | 24383568 |