def sample_list_metric_series_definitions():
# [START list_metric_series_definitions]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_metric_series_definitions(
metric_id=metric_id,
active_since=datetime.datetime(2020, 1, 1),
)
for result in results:
print(str(result))
def sample_list_metric_dimension_values():
# [START list_metric_dimension_values]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
dimension_name = "city"
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_metric_dimension_values(
metric_id=metric_id,
dimension_name=dimension_name,
)
for result in results:
print(str(result))
def sample_list_anomalies_for_alert(alert_config_id, alert_id):
# [START list_anomalies_for_alert]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_anomalies(
alert_configuration_id=alert_config_id,
alert_id=alert_id,
)
for result in results:
print("Create time: {}".format(result.created_time))
print("Severity: {}".format(result.severity))
print("Status: {}".format(result.status))
def sample_update_hook(hook):
# [START update_hook]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
hook.name = "updated hook name"
hook.description = "updated hook description"
client.update_hook(hook, emails_to_alert=["*****@*****.**"])
updated = client.get_hook(hook.id)
print("Updated name: {}".format(updated.name))
print("Updated description: {}".format(updated.description))
print("Updated emails: {}".format(updated.emails_to_alert))
def sample_list_alert_configs():
# [START list_alert_configs]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
detection_configuration_id = os.getenv(
"METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
configs = client.list_alert_configurations(detection_configuration_id)
for config in configs:
print("Alert config name: {}".format(config.name))
print("Alert description: {}".format(config.description))
print("Ids of hooks associated with alert: {}\n".format(
config.hook_ids))
async def sample_list_detection_configs_async():
# [START list_detection_configs_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
configs = client.list_detection_configurations(metric_id=metric_id)
async for config in configs:
print("Detection config name: {}".format(config.name))
print("Description: {}".format(config.description))
print("Metric ID: {}\n".format(config.metric_id))
async def sample_delete_data_feed_async(data_feed_id):
# [START delete_data_feed_async]
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
async with client:
await client.delete_data_feed(data_feed_id)
try:
await client.get_data_feed(data_feed_id)
except ResourceNotFoundError:
print("Data feed successfully deleted.")
async def sample_get_data_feed_async(data_feed_id):
# [START get_data_feed_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
data_feed = await client.get_data_feed(data_feed_id)
print("ID: {}".format(data_feed.id))
print("Data feed name: {}".format(data_feed.name))
print("Created time: {}".format(data_feed.created_time))
print("Status: {}".format(data_feed.status))
print("Source type: {}".format(data_feed.source.data_source_type))
print("Granularity type: {}".format(
data_feed.granularity.granularity_type))
print("Data feed metrics: {}".format(
[metric.name for metric in data_feed.schema.metrics]))
print("Data feed dimensions: {}".format(
[dimension.name for dimension in data_feed.schema.dimensions]))
print("Data feed timestamp column: {}".format(
data_feed.schema.timestamp_column))
print("Ingestion data starting on: {}".format(
data_feed.ingestion_settings.ingestion_begin_time))
print("Data feed description: {}".format(
data_feed.options.data_feed_description))
print("Data feed rollup type: {}".format(
data_feed.options.rollup_settings.rollup_type))
print("Data feed rollup method: {}".format(
data_feed.options.rollup_settings.rollup_method))
print("Data feed fill setting: {}".format(
data_feed.options.missing_data_point_fill_settings.fill_type))
print("Data feed access mode: {}".format(
data_feed.options.access_mode))
async def sample_update_alert_config_async(alert_config):
# [START update_alert_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (MetricAlertConfiguration,
MetricAnomalyAlertScope,
MetricAnomalyAlertConditions,
MetricBoundaryCondition)
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
detection_configuration_id = os.getenv(
"METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
alert_config.name = "updated config name"
additional_alert = MetricAlertConfiguration(
detection_configuration_id=detection_configuration_id,
alert_scope=MetricAnomalyAlertScope(
scope_type="SeriesGroup",
series_group_in_scope={'city': 'Shenzhen'}),
alert_conditions=MetricAnomalyAlertConditions(
metric_boundary_condition=MetricBoundaryCondition(direction="Down",
lower=5)))
alert_config.metric_alert_configurations.append(additional_alert)
async with client:
updated = await client.update_alert_configuration(
alert_config,
cross_metrics_operator="OR",
description="updated alert config")
print("Updated alert name: {}".format(updated.name))
print("Updated alert description: {}".format(updated.description))
print("Updated cross metrics operator: {}".format(
updated.cross_metrics_operator))
print("Updated alert condition configuration scope type: {}".format(
updated.metric_alert_configurations[2].alert_scope.scope_type))
def sample_list_data_feed_ingestion_status():
# [START list_data_feed_ingestion_status]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
data_feed_id = os.getenv("METRICS_ADVISOR_DATA_FEED_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
ingestion_status = client.list_data_feed_ingestion_status(
data_feed_id, datetime.datetime(2020, 9, 20),
datetime.datetime(2020, 9, 25))
for status in ingestion_status:
print("Timestamp: {}".format(status.timestamp))
print("Status: {}".format(status.status))
print("Message: {}\n".format(status.message))
def sample_list_incidents_for_alert():
# [START list_incidents_for_alert]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
alert_configuration_id = os.getenv("METRICS_ADVISOR_ALERT_CONFIGURATION_ID")
alert_id = os.getenv("METRICS_ADVISOR_ALERT_ID")
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
results = client.list_incidents_for_alert(
alert_configuration_id=alert_configuration_id,
alert_id=alert_id,
)
for result in results:
print("Metric id: {}".format(result.metric_id))
print("Incident ID: {}".format(result.id))
print("Severity: {}".format(result.severity))
print("Status: {}".format(result.status))
def sample_list_incident_root_cause():
# [START list_incident_root_cause]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
detection_configuration_id = os.getenv(
"METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
incident_id = os.getenv("METRICS_ADVISOR_INCIDENT_ID")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_incident_root_causes(
detection_configuration_id=detection_configuration_id,
incident_id=incident_id,
)
for result in results:
print("Score: {}".format(result.score))
print("Description: {}".format(result.description))
async def sample_get_data_feed_ingestion_progress_async():
# [START get_data_feed_ingestion_progress_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
data_feed_id = os.getenv("METRICS_ADVISOR_DATA_FEED_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
progress = await client.get_data_feed_ingestion_progress(data_feed_id)
print("Lastest active timestamp: {}".format(
progress.latest_active_timestamp))
print("Latest successful timestamp: {}".format(
progress.latest_success_timestamp))
def sample_create_hook():
# [START create_hook]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import EmailNotificationHook
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
hook = client.create_hook(
hook=EmailNotificationHook(
name="email hook",
description="my email hook",
emails_to_alert=["*****@*****.**"],
external_link="https://docs.microsoft.com/en-us/azure/cognitive-services/metrics-advisor/how-tos/alerts"
)
)
return hook
def sample_list_incidents_for_detection_configuration():
# [START list_incidents_for_detection_configuration]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
anomaly_detection_configuration_id = os.getenv("METRICS_ADVISOR_ANOMALY_DETECTION_CONFIGURATION_ID")
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
results = client.list_incidents_for_detection_configuration(
detection_configuration_id=anomaly_detection_configuration_id,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 9, 9),
)
for result in results:
print("Metric id: {}".format(result.metric_id))
print("Incident ID: {}".format(result.id))
print("Severity: {}".format(result.severity))
print("Status: {}".format(result.status))
async def sample_create_datasource_credential_async():
# [START create_datasource_credential_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import DatasourceSqlConnectionString
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
connection_string = os.getenv("SQL_SERVER_CONNECTION_STRING")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
datasource_credential = await client.create_datasource_credential(
datasource_credential=DatasourceSqlConnectionString(
name="sql datasource credential",
connection_string=connection_string,
description="my datasource credential",
))
return datasource_credential
def sample_create_hook():
# [START create_hook]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import EmailNotificationHook
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
hook = client.create_hook(
hook=EmailNotificationHook(
name="email hook",
description="my email hook",
emails_to_alert=["*****@*****.**"],
external_link="https://adwiki.azurewebsites.net/articles/howto/alerts/create-hooks.html"
)
)
return hook
def sample_list_alerts(alert_config_id):
# [START list_alerts]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
results = client.list_alerts(
alert_configuration_id=alert_config_id,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 9, 9),
time_mode="AnomalyTime",
)
for result in results:
print("Alert id: {}".format(result.id))
print("Create on: {}".format(result.created_on))
return results
async def sample_list_metric_enrichment_status_async():
# [START list_metric_enrichment_status_async]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
async with client:
results = client.list_metric_enrichment_status(
metric_id=metric_id,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 10, 21),
)
async for result in results:
print(str(result))
def sample_list_metric_enriched_series_data():
# [START list_metric_enriched_series_data]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
detection_configuration_id = os.getenv(
"METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
series_identity = {"city": "Los Angeles"}
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_metric_enriched_series_data(
detection_configuration_id=detection_configuration_id,
start_time=datetime.datetime(2020, 9, 1),
end_time=datetime.datetime(2020, 11, 1),
series=[series_identity])
for result in results:
print(str(result))
async def sample_list_dimension_values_async():
# [START list_dimension_values_async]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
detection_configuration_id = os.getenv("METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
dimension_name = "city"
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
async with client:
results = client.list_dimension_values(
detection_configuration_id=detection_configuration_id,
dimension_name=dimension_name,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 10, 21),
)
async for result in results:
print(str(result))
def sample_list_metrics_series_data():
# [START list_metrics_series_data]
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
results = client.list_metrics_series_data(
metric_id=metric_id,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 10, 21),
series_to_filter=[{
"city": "Los Angeles",
"category": "Homemade"
}])
for result in results:
print(str(result))
async def sample_create_detection_config_async():
# [START create_detection_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
ChangeThresholdCondition,
HardThresholdCondition,
SmartDetectionCondition,
SuppressCondition,
MetricDetectionCondition,
)
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
metric_id = os.getenv("METRICS_ADVISOR_METRIC_ID")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
change_threshold_condition = ChangeThresholdCondition(
anomaly_detector_direction="Both",
change_percentage=20,
shift_point=10,
within_range=True,
suppress_condition=SuppressCondition(
min_number=5,
min_ratio=2
)
)
hard_threshold_condition = HardThresholdCondition(
anomaly_detector_direction="Up",
upper_bound=100,
suppress_condition=SuppressCondition(
min_number=2,
min_ratio=2
)
)
smart_detection_condition = SmartDetectionCondition(
anomaly_detector_direction="Up",
sensitivity=10,
suppress_condition=SuppressCondition(
min_number=2,
min_ratio=2
)
)
async with client:
detection_config = await client.create_detection_configuration(
name="my_detection_config",
metric_id=metric_id,
description="anomaly detection config for metric",
whole_series_detection_condition=MetricDetectionCondition(
condition_operator="OR",
change_threshold_condition=change_threshold_condition,
hard_threshold_condition=hard_threshold_condition,
smart_detection_condition=smart_detection_condition
)
)
return detection_config
MetricDetectionCondition,
MetricSeriesGroupDetectionCondition,
MetricSingleSeriesDetectionCondition,
SmartDetectionCondition,
SuppressCondition,
ChangeThresholdCondition,
HardThresholdCondition,
EmailNotificationHook,
WebNotificationHook,
)
# for pytest.parametrize
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY",
"metrics_advisor_subscription_key")
api_key = os.getenv("METRICS_ADVISOR_API_KEY", "metrics_advisor_api_key")
API_KEY = [MetricsAdvisorKeyCredential(subscription_key, api_key)]
AAD = ["AAD"]
CREDENTIALS = [MetricsAdvisorKeyCredential(subscription_key, api_key), "AAD"]
def ids(val):
if isinstance(val, MetricsAdvisorKeyCredential):
return "APIKey"
else:
return "AAD"
class MetricsAdvisorClientPreparer(object):
def __init__(self, client_cls, client_kwargs={}, **kwargs):
self.client_cls = client_cls
self.client_kwargs = client_kwargs
async def sample_get_detection_config_async(detection_config_id):
# [START get_detection_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
config = await client.get_detection_configuration(detection_config_id)
print("Detection config name: {}".format(config.name))
print("Description: {}".format(config.description))
print("Metric ID: {}".format(config.metric_id))
print("\nDetection conditions specified for configuration...")
print("\nWhole Series Detection Conditions:\n")
conditions = config.whole_series_detection_condition
print("Use {} operator for multiple detection conditions".format(
conditions.cross_conditions_operator))
print("Smart Detection Condition:")
print("- Sensitivity: {}".format(
conditions.smart_detection_condition.sensitivity))
print("- Detection direction: {}".format(
conditions.smart_detection_condition.anomaly_detector_direction))
print("- Suppress conditions: minimum number: {}; minimum ratio: {}".
format(
conditions.smart_detection_condition.suppress_condition.
min_number, conditions.smart_detection_condition.
suppress_condition.min_ratio))
print("Hard Threshold Condition:")
print("- Lower bound: {}".format(
conditions.hard_threshold_condition.lower_bound))
print("- Upper bound: {}".format(
conditions.hard_threshold_condition.upper_bound))
print("- Detection direction: {}".format(
conditions.smart_detection_condition.anomaly_detector_direction))
print("- Suppress conditions: minimum number: {}; minimum ratio: {}".
format(
conditions.smart_detection_condition.suppress_condition.
min_number, conditions.smart_detection_condition.
suppress_condition.min_ratio))
print("Change Threshold Condition:")
print("- Change percentage: {}".format(
conditions.change_threshold_condition.change_percentage))
print("- Shift point: {}".format(
conditions.change_threshold_condition.shift_point))
print("- Detect anomaly if within range: {}".format(
conditions.change_threshold_condition.within_range))
print("- Detection direction: {}".format(
conditions.smart_detection_condition.anomaly_detector_direction))
print("- Suppress conditions: minimum number: {}; minimum ratio: {}".
format(
conditions.smart_detection_condition.suppress_condition.
min_number, conditions.smart_detection_condition.
suppress_condition.min_ratio))
async def sample_get_alert_config_async(alert_config_id):
# [START get_alert_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
config = await client.get_alert_configuration(alert_config_id)
print("Alert config ID: {}".format(config.id))
print("Alert config name: {}".format(config.name))
print("Description: {}".format(config.description))
print("Ids of hooks associated with alert: {}".format(config.hook_ids))
print("Use {} operator for multiple alert conditions\n".format(
config.cross_metrics_operator))
print("Alert uses detection configuration ID: {}".format(
config.metric_alert_configurations[0].detection_configuration_id))
print("Alert scope type: {}".format(
config.metric_alert_configurations[0].alert_scope.scope_type))
print("Alert severity condition: min- {}, max- {}".format(
config.metric_alert_configurations[0].alert_conditions.
severity_condition.min_alert_severity,
config.metric_alert_configurations[0].alert_conditions.
severity_condition.max_alert_severity,
))
print("\nAlert uses detection configuration ID: {}".format(
config.metric_alert_configurations[1].detection_configuration_id))
print("Alert scope type: {}".format(
config.metric_alert_configurations[1].alert_scope.scope_type))
print("Top N: {}".format(config.metric_alert_configurations[1].
alert_scope.top_n_group_in_scope.top))
print("Point count used to look back: {}".format(
config.metric_alert_configurations[1].alert_scope.
top_n_group_in_scope.period))
print("Min top count: {}".format(
config.metric_alert_configurations[1].alert_scope.
top_n_group_in_scope.min_top_count))
print("Alert metric boundary condition direction: {}, upper bound: {}".
format(
config.metric_alert_configurations[1].alert_conditions.
metric_boundary_condition.direction,
config.metric_alert_configurations[1].alert_conditions.
metric_boundary_condition.upper,
))
print("Alert snooze condition, snooze point count: {}".format(
config.metric_alert_configurations[1].alert_snooze_condition.
auto_snooze, ))
print("Alert snooze scope: {}".format(
config.metric_alert_configurations[1].alert_snooze_condition.
snooze_scope, ))
print("Snooze only for successive anomalies?: {}".format(
config.metric_alert_configurations[1].alert_snooze_condition.
only_for_successive, ))
async def sample_create_alert_config_async():
# [START create_anomaly_alert_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
MetricAlertConfiguration,
MetricAnomalyAlertScope,
TopNGroupScope,
MetricAnomalyAlertConditions,
SeverityCondition,
MetricBoundaryCondition,
MetricAnomalyAlertSnoozeCondition,
AnomalyAlertConfiguration
)
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
anomaly_detection_configuration_id = os.getenv("METRICS_ADVISOR_DETECTION_CONFIGURATION_ID")
hook_id = os.getenv("METRICS_ADVISOR_HOOK_ID")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
anomaly_alert_configuration = AnomalyAlertConfiguration(
name="my alert config",
description="alert config description",
cross_metrics_operator="AND",
metric_alert_configurations=[
MetricAlertConfiguration(
detection_configuration_id=anomaly_detection_configuration_id,
alert_scope=MetricAnomalyAlertScope(
scope_type="WholeSeries"
),
alert_conditions=MetricAnomalyAlertConditions(
severity_condition=SeverityCondition(
min_alert_severity="Low",
max_alert_severity="High"
)
)
),
MetricAlertConfiguration(
detection_configuration_id=anomaly_detection_configuration_id,
alert_scope=MetricAnomalyAlertScope(
scope_type="TopN",
top_n_group_in_scope=TopNGroupScope(
top=10,
period=5,
min_top_count=5
)
),
alert_conditions=MetricAnomalyAlertConditions(
metric_boundary_condition=MetricBoundaryCondition(
direction="Up",
upper=50
)
),
alert_snooze_condition=MetricAnomalyAlertSnoozeCondition(
auto_snooze=2,
snooze_scope="Metric",
only_for_successive=True
)
),
],
hook_ids=[hook_id]
)
async with client:
alert_config = await client.create_anomaly_alert_configuration(anomaly_alert_configuration)
return alert_config
def __init__(self, method_name):
super(TestMetricsAdvisorAdministrationClientBase, self).__init__(method_name)
self.vcr.match_on = ["path", "method", "query"]
if self.is_live:
service_endpoint = self.get_settings_value("METRICS_ADVISOR_ENDPOINT")
subscription_key = self.get_settings_value("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = self.get_settings_value("METRICS_ADVISOR_API_KEY")
self.sql_server_connection_string = self.get_settings_value("METRICS_ADVISOR_SQL_SERVER_CONNECTION_STRING")
self.azure_table_connection_string = self.get_settings_value("METRICS_ADVISOR_AZURE_TABLE_CONNECTION_STRING")
self.azure_blob_connection_string = self.get_settings_value("METRICS_ADVISOR_AZURE_BLOB_CONNECTION_STRING")
self.azure_cosmosdb_connection_string = self.get_settings_value("METRICS_ADVISOR_COSMOS_DB_CONNECTION_STRING")
self.http_request_get_url = self.get_settings_value("METRICS_ADVISOR_HTTP_GET_URL")
self.http_request_post_url = self.get_settings_value("METRICS_ADVISOR_HTTP_POST_URL")
self.application_insights_api_key = self.get_settings_value("METRICS_ADVISOR_APPLICATION_INSIGHTS_API_KEY")
self.azure_data_explorer_connection_string = self.get_settings_value("METRICS_ADVISOR_AZURE_DATA_EXPLORER_CONNECTION_STRING")
self.influxdb_connection_string = self.get_settings_value("METRICS_ADVISOR_INFLUX_DB_CONNECTION_STRING")
self.influxdb_password = self.get_settings_value("METRICS_ADVISOR_INFLUX_DB_PASSWORD")
self.azure_datalake_account_key = self.get_settings_value("METRICS_ADVISOR_AZURE_DATALAKE_ACCOUNT_KEY")
self.mongodb_connection_string = self.get_settings_value("METRICS_ADVISOR_AZURE_MONGO_DB_CONNECTION_STRING")
self.mysql_connection_string = self.get_settings_value("METRICS_ADVISOR_MYSQL_CONNECTION_STRING")
self.postgresql_connection_string = self.get_settings_value("METRICS_ADVISOR_POSTGRESQL_CONNECTION_STRING")
self.elasticsearch_auth_header = self.get_settings_value("METRICS_ADVISOR_ELASTICSEARCH_AUTH_HEADER")
self.anomaly_detection_configuration_id = self.get_settings_value("METRICS_ADVISOR_ANOMALY_DETECTION_CONFIGURATION_ID")
self.data_feed_id = self.get_settings_value("METRICS_ADVISOR_DATA_FEED_ID")
self.metric_id = self.get_settings_value("METRICS_ADVISOR_METRIC_ID")
self.scrubber.register_name_pair(
self.sql_server_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.azure_table_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.azure_blob_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.azure_cosmosdb_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.http_request_get_url,
"connectionstring"
)
self.scrubber.register_name_pair(
self.http_request_post_url,
"connectionstring"
)
self.scrubber.register_name_pair(
self.application_insights_api_key,
"connectionstring"
)
self.scrubber.register_name_pair(
self.azure_data_explorer_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.influxdb_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.influxdb_password,
"connectionstring"
)
self.scrubber.register_name_pair(
self.azure_datalake_account_key,
"connectionstring"
)
self.scrubber.register_name_pair(
self.mongodb_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.mysql_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.postgresql_connection_string,
"connectionstring"
)
self.scrubber.register_name_pair(
self.elasticsearch_auth_header,
"connectionstring"
)
self.scrubber.register_name_pair(
self.metric_id,
"metric_id"
)
self.scrubber.register_name_pair(
self.data_feed_id,
"data_feed_id"
)
self.scrubber.register_name_pair(
self.anomaly_detection_configuration_id,
"anomaly_detection_configuration_id"
)
else:
service_endpoint = "https://endpointname.cognitiveservices.azure.com"
subscription_key = "METRICS_ADVISOR_SUBSCRIPTION_KEY"
api_key = "METRICS_ADVISOR_API_KEY"
self.sql_server_connection_string = "SQL_SERVER_CONNECTION_STRING"
self.azure_table_connection_string = "AZURE_TABLE_CONNECTION_STRING"
self.azure_blob_connection_string = "AZURE_BLOB_CONNECTION_STRING"
self.azure_cosmosdb_connection_string = "COSMOS_DB_CONNECTION_STRING"
self.http_request_get_url = "METRICS_ADVISOR_HTTP_GET_URL"
self.http_request_post_url = "METRICS_ADVISOR_HTTP_POST_URL"
self.application_insights_api_key = "METRICS_ADVISOR_APPLICATION_INSIGHTS_API_KEY"
self.azure_data_explorer_connection_string = "METRICS_ADVISOR_AZURE_DATA_EXPLORER_CONNECTION_STRING"
self.influxdb_connection_string = "METRICS_ADVISOR_INFLUXDB_CONNECTION_STRING"
self.influxdb_password = "******"
self.azure_datalake_account_key = "METRICS_ADVISOR_AZURE_DATALAKE_ACCOUNT_KEY"
self.mongodb_connection_string = "METRICS_ADVISOR_AZURE_MONGODB_CONNECTION_STRING"
self.mysql_connection_string = "METRICS_ADVISOR_MYSQL_CONNECTION_STRING"
self.postgresql_connection_string = "METRICS_ADVISOR_POSTGRESQL_CONNECTION_STRING"
self.elasticsearch_auth_header = "METRICS_ADVISOR_ELASTICSEARCH_AUTH"
self.anomaly_detection_configuration_id = "anomaly_detection_configuration_id"
self.metric_id = "metric_id"
self.data_feed_id = "data_feed_id"
self.admin_client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
def sample_create_data_feed():
# [START create_data_feed]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
SQLServerDataFeed,
DataFeedSchema,
DataFeedMetric,
DataFeedDimension,
DataFeedOptions,
DataFeedRollupSettings,
DataFeedMissingDataPointFillSettings,
DataFeedGranularity,
DataFeedIngestionSettings,
DataFeed
)
service_endpoint = os.getenv("METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("METRICS_ADVISOR_API_KEY")
sql_server_connection_string = os.getenv("METRICS_ADVISOR_SQL_SERVER_CONNECTION_STRING")
query = os.getenv("METRICS_ADVISOR_SQL_SERVER_QUERY")
client = MetricsAdvisorAdministrationClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
data_feed = DataFeed(
name="My data feed",
source=SQLServerDataFeed(
connection_string=sql_server_connection_string,
query=query,
),
granularity=DataFeedGranularity("Daily"),
schema=DataFeedSchema(
metrics=[
DataFeedMetric(name="cost", display_name="Cost"),
DataFeedMetric(name="revenue", display_name="Revenue")
],
dimensions=[
DataFeedDimension(name="category", display_name="Category"),
DataFeedDimension(name="city", display_name="City")
],
timestamp_column="Timestamp"
),
ingestion_settings=DataFeedIngestionSettings(
ingestion_begin_time=datetime.datetime(2019, 10, 1)
),
options=DataFeedOptions(
data_feed_description="cost/revenue data feed",
rollup_settings=DataFeedRollupSettings(
rollup_type="AutoRollup",
rollup_method="Sum",
rollup_identification_value="__CUSTOM_SUM__"
),
missing_data_point_fill_settings=DataFeedMissingDataPointFillSettings(
fill_type="SmartFilling"
),
access_mode="Private"
)
)
my_sql_data_feed = client.create_data_feed(data_feed)
return my_sql_data_feed
