add quickstart

Author: aprilk-ms

eval/setup-eval.py

@@ -111,7 +111,7 @@ def get_evaluator_config_safety(evaluator_id, azure_ai_project_scope):
     "sexual" : get_evaluator_config_safety(SexualEvaluator.id, project_client.scope),
     "hateUnfairness" : get_evaluator_config_safety(HateUnfairnessEvaluator.id, project_client.scope),
     "protectedMaterial" : get_evaluator_config_safety(ProtectedMaterialEvaluator.id, project_client.scope),
-    "contentSafety" : get_evaluator_config_safety(ContentSafetyEvaluator.id, project_client.scope)
+    #"contentSafety" : get_evaluator_config_safety("azureml://registries/azureml/models/Content-Safety-Evaluator/versions/1", project_client.scope)
 }
 
 name = SAMPLE_NAME

quickstart-dotnet.md

@@ -0,0 +1,68 @@
+# ASP.NET
+See [here](https://learn.microsoft.com/en-us/azure/azure-app-configuration/howto-variant-feature-flags-aspnet-core) for the full tutorial.
+
+
+## Install SDK via .NET CLI
+
+```
+dotnet add package Azure.Identity
+dotnet add package Microsoft.Extensions.Configuration.AzureAppConfiguration
+dotnet add package Microsoft.FeatureManagement.AspNetCore
+```
+
+## Initialize Application Insights
+
+[Connect to Application Insights](https://learn.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core) to instrument your application.
+
+```dotnet
+builder.Services.AddApplicationInsightsTelemetry();
+```
+
+## Initialize App Configuration
+
+[Connect to App Configuration](https://learn.microsoft.com/en-us/azure/azure-app-configuration/quickstart-aspnet-core-app?tabs=entra-id), which supplies feature flags and other configurations to your application. 
+Use `DefaultAzureCredential` to authenticate to your App Configuration store. Follow the [instructions](https://learn.microsoft.com/en-us/azure/azure-app-configuration/concept-enable-rbac#authentication-with-token-credentials) to assign your credential the App Configuration Data Reader role. 
+
+
+```dotnet
+builder.Configuration.AddAzureAppConfiguration(options =>
+{
+    options.Connect(new Uri(endpoint), new DefaultAzureCredential());
+});
+```
+
+## Setup Feature Management
+
+Add Feature Management to the service collection and the targeting middleware to provide user Id for variant assignments.
+
+```dotnet
+builder.Services.AddFeatureManagement()
+    .WithTargeting()
+    .AddApplicationInsightsTelemetry();
+ 
+app.UseMiddleware<TargetingHttpContextMiddleware>();
+```
+
+## Use Feature Flag
+
+Use dependency injection to retrieve an instance of `IVariantFeatureManager` and get the feature variant assigned to the user. 
+
+```dotnet
+Variant variant = await featureManager
+    .GetVariantAsync("<placeholder-feature-flag-name>", HttpContext.RequestAborted);
+```
+
+## Log Events
+Use dependency injection to retrieve `TelemetryClient` to log custom events.
+
+```dotnet
+telemetryClient.TrackEvent("<placeholder-event-name>");
+```
+
+## Validate Event Logs
+- Run your application and trigger one or more get_variant() calls for the test feature flag.
+- Go to the Log Analytics workspace (add link to LA workspace/log page) and execute the following query. After a short ingestion delay, you should see the log events for the feature evaluation calls.
+
+```
+AppEvents | where Name == "FeatureEvaluation"
+```

quickstart-python.md

@@ -0,0 +1,74 @@
+# Python
+See [here](https://learn.microsoft.com/en-us/azure/azure-app-configuration/howto-variant-feature-flags-python) for the full tutorial.
+
+## Install SDK
+
+```
+pip install azure-identity 
+pip install azure-appconfiguration-provider
+pip install featuremanagement[AzureMonitor]
+```
+
+## Define a targeting context accessor method
+
+The accessor method is called from both Feature Management and Azure Monitor to identify the user for the current request.
+
+```python
+async def my_targeting_accessor() -> TargetingContext:
+    user_id = request.headers.get('user-id', str(uuid.uuid4())
+    return TargetingContext(user_id=user_id)
+```
+
+## Initialize Application Insights
+
+[Connect to Application Insights](https://learn.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core) to instrument your application. Include the `TargetingSpanProcessor` to allow request and dependency data to be available for metrics.
+
+```python
+from azure.monitor.opentelemetry import configure_azure_monitor
+from featuremanagement.azuremonitor import TargetingSpanProcessor
+
+configure_azure_monitor(
+    connection_string=os.getenv("APPLICATIONINSIGHTS_CONNECTION_STRING"),
+    span_processors=[TargetingSpanProcessor(targeting_context_accessor=my_targeting_accessor)]
+)
+```
+
+## Initialize App Configuration and Feature Manager
+
+[Connect to App Configuration](https://learn.microsoft.com/azure/azure-app-configuration/quickstart-feature-flag-python#console-applications), which supplies feature flags and other configurations to your application. Use `DefaultAzureCredential` to authenticate to your App Configuration store. Follow the [instructions](https://learn.microsoft.com/en-us/azure/azure-app-configuration/concept-enable-rbac#authentication-with-token-credentials) to assign your credential the App Configuration Data Reader role. 
+
+```python
+from azure.appconfiguration.provider import load
+from azure.identity import DefaultAzureCredential
+from featuremanagement import FeatureManager
+from featuremanagement.azuremonitor import publish_telemetry, track_event
+
+azure_app_config = load(endpoint="<your-endpoint>", credential=DefaultAzureCredential(), feature_flag_enabled=True, feature_flag_refresh_enabled=True)
+feature_manager = FeatureManager(azure_app_config, on_feature_evaluated=publish_telemetry, targeting_context_accessor=my_targeting_accessor)
+```
+
+## Use Feature Flag
+
+Use feature manager to get the feature variant assigned to the user.
+
+```python
+my_feature_flag = feature_manager.get_variant("<placeholder-feature-flag-name>"):
+if my_feature_flag:
+    variant_name = my_feature_flag.name
+    variant_value = my_feature_flag.configuration
+    # do something with the variant value
+```
+
+## Log event
+```
+# The user_id from the targeting context needs to be manually added for now due to an missing Azure Monitor support.
+track_event("<placeholder-event-name>", my_targeting_accessor().user_id)
+```
+
+## Validate Event Logs
+- Run your application and trigger one or more get_variant() calls for the test feature flag.
+- Go to the Log Analytics workspace (add link to LA workspace/log page) and execute the following query. After a short ingestion delay, you should see the log events for the feature evaluation calls.
+
+```
+AppEvents | where Name == "FeatureEvaluation"
+```

src/api/test_ai_eval.py

@@ -33,7 +33,7 @@ def get_prompt_template_variants():
 def test_simulate_traffic():
     app = create_app()
     with TestClient(app) as client:
-        for i in range(20):
+        for i in range(1):
             for data in get_eval_data_set():
                 query = data["query"]
                 response = client.post("/chat", json={