def __init__(self, arguments):
super().__init__(arguments)
service_endpoint = os.getenv("AZURE_METRICS_ADVISOR_ENDPOINT")
subscription_key = os.getenv("AZURE_METRICS_ADVISOR_SUBSCRIPTION_KEY")
api_key = os.getenv("AZURE_METRICS_ADVISOR_API_KEY")
self.anomaly_detection_configuration_id = os.getenv(
"AZURE_METRICS_ADVISOR_ANOMALY_DETECTION_CONFIGURATION_ID")
self.service_client = SyncClient(
service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
self.async_service_client = AsyncClient(
service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
def sample_get_detection_config(detection_config_id):
# [START get_detection_config]
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))
config = 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.condition_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))
def test_credential_bad_input(self):
credential = MetricsAdvisorKeyCredential(self.subscription_key,
self.api_key)
with pytest.raises(TypeError):
credential.update_key(subscription_key=34)
with pytest.raises(TypeError):
credential.update_key(api_key=34)
async def sample_list_metrics_series_data_async():
# [START list_metrics_series_data_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_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"}
]
)
async for result in results:
print(str(result))
async def sample_create_detection_config_async():
# [START create_anomaly_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_metric_anomaly_detection_configuration(
name="my_detection_config",
metric_id=metric_id,
description="anomaly detection config for metric",
whole_series_detection_condition=MetricDetectionCondition(
cross_conditions_operator="OR",
change_threshold_condition=change_threshold_condition,
hard_threshold_condition=hard_threshold_condition,
smart_detection_condition=smart_detection_condition
)
)
return detection_config
def test_credential_rotate_both_keys(self):
credential = MetricsAdvisorKeyCredential(self.subscription_key,
self.api_key)
client = MetricsAdvisorClient(self.service_endpoint, credential)
# make successful call
result = client.get_feedback(feedback_id=self.feedback_id)
assert result
# rotate both keys
credential.update_key(subscription_key="xxx")
assert credential.subscription_key == "xxx"
credential.update_key(api_key="xxx")
assert credential.api_key == "xxx"
# call fails
with pytest.raises(ClientAuthenticationError):
result = client.get_feedback(feedback_id=self.feedback_id)
# rotate back to valid credentials
credential.update_key(subscription_key=self.subscription_key)
assert credential.subscription_key == self.subscription_key
credential.update_key(api_key=self.api_key)
assert credential.api_key == self.api_key
# make successful call
result = client.get_feedback(feedback_id=self.feedback_id)
assert result
def sample_list_data_feeds():
# [START list_data_feeds]
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))
data_feeds = client.list_data_feeds()
for feed in data_feeds:
print("Data feed name: {}".format(feed.name))
print("ID: {}".format(feed.id))
print("Created time: {}".format(feed.created_time))
print("Status: {}".format(feed.status))
print("Source type: {}".format(feed.source.data_source_type))
print("Granularity type: {}".format(feed.granularity.granularity_type))
print("\nFeed metrics:")
for metric in feed.schema.metrics:
print(metric.name)
print("\nFeed dimensions:")
for dimension in feed.schema.dimensions:
print(dimension.name)
async def sample_list_alerts_async(alert_config_id):
# [START list_alerts_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")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
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",
)
tolist = []
async for result in results:
tolist.append(result)
print("Alert id: {}".format(result.id))
print("Create on: {}".format(result.created_on))
return tolist
async def sample_list_incidents_for_detection_configuration_async():
# [START list_incidents_for_detection_configuration_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")
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
results = client.list_incidents(
detection_configuration_id=detection_configuration_id,
start_time=datetime.datetime(2020, 1, 1),
end_time=datetime.datetime(2020, 9, 9),
)
async 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_list_incidents_for_alert_async():
# [START list_incidents_for_alert_async]
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")
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))
async with client:
results = client.list_incidents(
alert_configuration_id=alert_configuration_id,
alert_id=alert_id,
)
async 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_list_metric_enriched_series_data_async():
# [START list_metric_enriched_series_data_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")
series_identity = {"region": "Los Angeles"}
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
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])
async for result in results:
print(str(result))
async def sample_list_anomaly_dimension_values_async():
# [START list_anomaly_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 = "region"
client = MetricsAdvisorClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
results = client.list_anomaly_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))
async def sample_create_hook_async():
# [START create_hook_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import EmailHook
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:
hook = await client.create_hook(
name="email hook",
hook=EmailHook(
description="my email hook",
emails_to_alert=["*****@*****.**"],
external_link=
"https://adwiki.azurewebsites.net/articles/howto/alerts/create-hooks.html"
))
return hook
def sample_update_data_feed(data_feed):
# [START update_data_feed]
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))
# update data feed on the data feed itself or by using available keyword arguments
data_feed.name = "updated name"
data_feed.data_feed_description = "updated description for data feed"
updated = client.update_data_feed(data_feed,
access_mode="Public",
fill_type="CustomValue",
custom_fill_value=1)
print("Updated name: {}".format(updated.name))
print("Updated description: {}".format(updated.data_feed_description))
print("Updated access mode: {}".format(updated.access_mode))
print("Updated fill setting, value: {}, {}".format(
updated.missing_data_point_fill_settings.fill_type,
updated.missing_data_point_fill_settings.custom_fill_value,
))
def sample_get_data_feed(data_feed_id):
# [START get_data_feed]
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))
data_feed = 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))
def test_credential_rotate_api_key_only(self):
credential = MetricsAdvisorKeyCredential(self.subscription_key,
self.api_key)
client = MetricsAdvisorClient(self.service_endpoint, credential)
# make successful call
result = client.get_feedback(feedback_id=self.feedback_id)
assert result
# rotate one key
credential.update_api_key("xxx")
assert credential.subscription_key == self.subscription_key
assert credential.api_key == "xxx"
# call fails
with pytest.raises(HttpResponseError):
result = client.get_feedback(feedback_id=self.feedback_id)
# rotate back to valid credentials
credential.update_api_key(self.api_key)
assert credential.subscription_key == self.subscription_key
assert credential.api_key == self.api_key
# make successful call
result = client.get_feedback(feedback_id=self.feedback_id)
assert result
def sample_get_alert_config(alert_config_id):
# [START get_anomaly_alert_config]
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))
config = client.get_anomaly_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_data_feed_async():
# [START create_data_feed_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
SQLServerDataFeed,
DataFeedSchema,
Metric,
Dimension,
DataFeedOptions,
DataFeedRollupSettings,
DataFeedMissingDataPointFillSettings
)
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))
async with client:
data_feed = await client.create_data_feed(
name="My data feed",
source=SQLServerDataFeed(
connection_string=sql_server_connection_string,
query=query,
),
granularity="Daily",
schema=DataFeedSchema(
metrics=[
Metric(name="cost", display_name="Cost"),
Metric(name="revenue", display_name="Revenue")
],
dimensions=[
Dimension(name="category", display_name="Category"),
Dimension(name="city", display_name="City")
],
timestamp_column="Timestamp"
),
ingestion_settings=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"
)
)
return data_feed
def __init__(self, method_name):
super(TestMetricsAdvisorClientBase, 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.anomaly_detection_configuration_id = self.get_settings_value("METRICS_ADVISOR_ANOMALY_DETECTION_CONFIGURATION_ID")
self.anomaly_alert_configuration_id = self.get_settings_value("METRICS_ADVISOR_ANOMALY_ALERT_CONFIGURATION_ID")
self.metric_id = self.get_settings_value("METRICS_ADVISOR_METRIC_ID")
self.incident_id = self.get_settings_value("METRICS_ADVISOR_INCIDENT_ID")
self.dimension_name = self.get_settings_value("METRICS_ADVISOR_DIMENSION_NAME")
self.feedback_id = self.get_settings_value("METRICS_ADVISOR_FEEDBACK_ID")
self.alert_id = self.get_settings_value("METRICS_ADVISOR_ALERT_ID")
self.scrubber.register_name_pair(
self.anomaly_detection_configuration_id,
"anomaly_detection_configuration_id"
)
self.scrubber.register_name_pair(
self.anomaly_alert_configuration_id,
"anomaly_alert_configuration_id"
)
self.scrubber.register_name_pair(
self.metric_id,
"metric_id"
)
self.scrubber.register_name_pair(
self.incident_id,
"incident_id"
)
self.scrubber.register_name_pair(
self.dimension_name,
"dimension_name"
)
self.scrubber.register_name_pair(
self.feedback_id,
"feedback_id"
)
self.scrubber.register_name_pair(
self.alert_id,
"alert_id"
)
else:
service_endpoint = "https://endpointname.cognitiveservices.azure.com"
subscription_key = "METRICS_ADVISOR_SUBSCRIPTION_KEY"
api_key = "METRICS_ADVISOR_API_KEY"
self.anomaly_detection_configuration_id = "anomaly_detection_configuration_id"
self.anomaly_alert_configuration_id = "anomaly_alert_configuration_id"
self.metric_id = "metric_id"
self.incident_id = "incident_id"
self.dimension_name = "dimension_name"
self.feedback_id = "feedback_id"
self.alert_id = "alert_id"
self.client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
async def sample_create_alert_config_async():
# [START create_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,
)
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")
hook_id = os.getenv("METRICS_ADVISOR_HOOK_ID")
client = MetricsAdvisorAdministrationClient(
service_endpoint, MetricsAdvisorKeyCredential(subscription_key,
api_key))
async with client:
alert_config = await client.create_alert_configuration(
name="my alert config",
description="alert config description",
cross_metrics_operator="AND",
metric_alert_configurations=[
MetricAlertConfiguration(
detection_configuration_id=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=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])
return alert_config
def authentication_administration_client_with_metrics_advisor_credential():
# [START administration_client_with_metrics_advisor_credential]
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))
async def sample_update_detection_config_async(detection_config):
# [START update_detection_config_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
MetricSeriesGroupDetectionCondition,
MetricSingleSeriesDetectionCondition,
SmartDetectionCondition,
SuppressCondition
)
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))
detection_config.name = "updated config name"
detection_config.description = "updated with more detection conditions"
smart_detection_condition = SmartDetectionCondition(
anomaly_detector_direction="Up",
sensitivity=10,
suppress_condition=SuppressCondition(
min_number=2,
min_ratio=2
)
)
async with client:
updated = await client.update_detection_configuration(
detection_config,
series_group_detection_conditions=[
MetricSeriesGroupDetectionCondition(
series_group_key={"city": "Seoul"},
smart_detection_condition=smart_detection_condition
)
],
series_detection_conditions=[
MetricSingleSeriesDetectionCondition(
series_key={"city": "Osaka", "category": "Cell Phones"},
smart_detection_condition=smart_detection_condition
)
]
)
print("Updated detection name: {}".format(updated.name))
print("Updated detection description: {}".format(updated.description))
print("Updated detection condition for series group: {}".format(
updated.series_group_detection_conditions[0].series_group_key
))
print("Updated detection condition for series: {}".format(
updated.series_detection_conditions[0].series_key
))
async def sample_delete_datasource_credential_async(credential_id):
# [START delete_datasource_credential_async]
from azure.core.exceptions import ResourceNotFoundError
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))
await client.delete_datasource_credential(credential_id)
async def sample_get_feedback_async():
# [START get_feedback_async]
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")
feedback_id = os.getenv("METRICS_ADVISOR_FEEDBACK_ID")
client = MetricsAdvisorClient(service_endpoint,
MetricsAdvisorKeyCredential(subscription_key, api_key))
result = await client.get_feedback(feedback_id=feedback_id)
print("Type: {}; Id: {}".format(result.feedback_type, result.id))
async def sample_list_feedback_async():
# [START list_feedback_async]
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_feedback(metric_id=metric_id)
async for result in results:
print("Type: {}; Id: {}".format(result.feedback_type, result.id))
def sample_list_hooks():
# [START list_hooks]
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))
hooks = client.list_hooks()
for hook in hooks:
print("Hook type: {}".format(hook.hook_type))
print("Hook name: {}".format(hook.name))
print("Description: {}\n".format(hook.description))
async def sample_list_datasource_credentials_async():
# [START list_datasource_credentials_async]
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))
credentials = client.list_datasource_credentials()
async for credential in credentials:
print("Credential type: {}".format(credential.credential_type))
print("Credential name: {}".format(credential.name))
print("Description: {}\n".format(credential.description))
async def sample_update_alert_config_async(alert_config):
# [START update_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,
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")
anomaly_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=anomaly_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_anomaly_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_refresh_data_feed_ingestion():
# [START refresh_data_feed_ingestion]
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))
client.refresh_data_feed_ingestion(data_feed_id,
datetime.datetime(2020, 9, 20),
datetime.datetime(2020, 9, 25))
async def sample_add_feedback_async():
# [START add_feedback_async]
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorClient
from azure.ai.metricsadvisor.models import AnomalyFeedback, ChangePointFeedback, CommentFeedback, PeriodFeedback
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))
anomaly_feedback = AnomalyFeedback(metric_id=metric_id,
dimension_key={"Dim1": "Common Lime"},
start_time=datetime.datetime(
2020, 8, 5),
end_time=datetime.datetime(2020, 8, 7),
value="NotAnomaly")
await client.add_feedback(anomaly_feedback)
change_point_feedback = ChangePointFeedback(
metric_id=metric_id,
dimension_key={"Dim1": "Common Lime"},
start_time=datetime.datetime(2020, 8, 5),
end_time=datetime.datetime(2020, 8, 7),
value="NotChangePoint")
await client.add_feedback(change_point_feedback)
comment_feedback = CommentFeedback(metric_id=metric_id,
dimension_key={"Dim1": "Common Lime"},
start_time=datetime.datetime(
2020, 8, 5),
end_time=datetime.datetime(2020, 8, 7),
value="comment")
await client.add_feedback(comment_feedback)
period_feedback = PeriodFeedback(metric_id=metric_id,
dimension_key={"Dim1": "Common Lime"},
start_time=datetime.datetime(2020, 8, 5),
end_time=datetime.datetime(2020, 8, 7),
period_type="AssignValue",
value=2)
await client.add_feedback(period_feedback)
