Nastavení služby Azure Monitor pro aplikaci v Pythonu

Azure Monitor podporuje distribuované trasování, shromažďování metrik a protokolování aplikací Pythonu.

Podporované řešení Microsoftu pro sledování a export dat pro aplikace Pythonu je prostřednictvím sady OpenCensus Python SDK prostřednictvím exportérů služby Azure Monitor.

Microsoft nedoporučuje používat žádné další sady SDK telemetrie pro Python jako řešení telemetrie, protože nejsou podporované.

OpenCensus se konverguje do OpenTelemetry. I nadále doporučujeme OpenCensus, zatímco OpenTelemetry postupně zraje.

Požadavky

Musíte mít předplatné Azure. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet.

Představujeme sadu OpenCensus Python SDK

OpenCensus je sada opensourcových knihoven, která umožňuje shromažďování distribuovaných trasování, metrik a protokolování telemetrie. Pomocí exportérů azure Monitoru můžete tuto shromážděnou telemetrii odeslat do Application Insights. Tento článek vás provede procesem nastavení exportérů OpenCensus a Azure Monitoru pro Python k odesílání dat monitorování do služby Azure Monitor.

Instrumentace pomocí sady OpenCensus Python SDK s využitím exportérů služby Azure Monitor

Nainstalujte exportéry Služby Azure Monitor OpenCensus:

python -m pip install opencensus-ext-azure

Sada SDK používá tři vývozce Azure Monitoru k odesílání různých typů telemetrie do služby Azure Monitor. traceJsou to , metricsa logs. Další informace o těchto typech telemetrie najdete v přehledu datové platformy. Pomocí následujících pokynů odešlete tyto typy telemetrie prostřednictvím tří exportérů.

Mapování typů telemetrie

OpenCensus mapuje následující vývozce na typy telemetrie, které vidíte ve službě Azure Monitor.

Protokoly

1. Nejprve vygenerujme nějaká místní data protokolu.

   
   import logging
   
   logger = logging.getLogger(__name__)
   
   def main():
       """Generate random log data."""
       for num in range(5):
           logger.warning(f"Log Entry - {num}")
   
   if __name__ == "__main__":
       main()
   

2. Pro každé číslo v oblasti se vygeneruje položka protokolu.

   Log Entry - 0
   Log Entry - 1
   Log Entry - 2
   Log Entry - 3
   Log Entry - 4
   

3. Chceme zobrazit tato data protokolu do služby Azure Monitor. Můžete ho zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . Můžete také předat connection_string přímo do AzureLogHandler, ale připojovací řetězec by se neměly přidávat do správy verzí.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Doporučujeme použít připojovací řetězec k vytvoření instance exportérů, kteří se používají k odesílání telemetrie do Application Insights. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   import logging
   from opencensus.ext.azure.log_exporter import AzureLogHandler
   
   logger = logging.getLogger(__name__)
   logger.addHandler(AzureLogHandler())
   
   # Alternatively manually pass in the connection_string
   # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))
   
   """Generate random log data."""
   for num in range(5):
       logger.warning(f"Log Entry - {num}")
   

4. Vývozce odešle data protokolu do služby Azure Monitor. Data najdete v části traces.

   V tomto kontextu traces není totéž jako tracing. Tady se odkazuje na typ telemetrie, traces kterou vidíte ve službě Azure Monitor při využití AzureLogHandler. Odkazuje ale tracing na koncept v OpenCensus a vztahuje se k distribuovanému trasování.

   Poznámka:

   Kořenový protokolovací nástroj je nakonfigurován na úrovni warning. To znamená, že všechny protokoly, které odesíláte s nižší závažností, se ignorují a naopak se neodesílají do služby Azure Monitor. Další informace najdete v dokumentaci k protokolování.

5. Vlastní vlastnosti můžete také přidat do zpráv protokolu v argumentu extra klíčového slova pomocí custom_dimensions pole. Tyto vlastnosti se v Azure Monitoru zobrazují jako páry customDimensions klíč-hodnota.

   Poznámka:

   Aby tato funkce fungovala, musíte do custom_dimensions pole předat slovník. Pokud předáte argumenty jiného typu, protokolovací funkce je ignoruje.

   import logging
   
   from opencensus.ext.azure.log_exporter import AzureLogHandler
   
   logger = logging.getLogger(__name__)
   logger.addHandler(AzureLogHandler())
   # Alternatively manually pass in the connection_string
   # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))
   
   properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}
   
   # Use properties in logging statements
   logger.warning('action', extra=properties)
   

Konfigurace protokolování pro aplikace Django

Protokolování můžete nakonfigurovat explicitně v kódu aplikace, jako je tomu u předchozích aplikací Django, nebo ho můžete zadat v konfiguraci protokolování Django. Tento kód může přejít do libovolného souboru, který používáte pro konfiguraci nastavení webu Django, obvykle settings.py.

Informace o konfiguraci nastavení Django naleznete v tématu Nastavení Django. Další informace o konfiguraci protokolování naleznete v tématu Django protokolování.

LOGGING = {
    "handlers": {
        "azure": {
            "level": "DEBUG",
            "class": "opencensus.ext.azure.log_exporter.AzureLogHandler",
            "connection_string": "<appinsights-connection-string>",
        },
        "console": {
            "level": "DEBUG",
            "class": "logging.StreamHandler",
            "stream": sys.stdout,
        },
      },
    "loggers": {
        "logger_name": {"handlers": ["azure", "console"]},
    },
}

Ujistěte se, že používáte protokolovací nástroj se stejným názvem jako ten, který jste zadali v konfiguraci.

# views.py

import logging
from django.shortcuts import request

logger = logging.getLogger("logger_name")
logger.warning("this will be tracked")

Odesílání výjimek

OpenCensus Python automaticky nesleduje a neodesílá exception telemetrii. Odesílá se prostřednictvím AzureLogHandler výjimek prostřednictvím knihovny protokolování Pythonu. Vlastní vlastnosti můžete přidat stejně jako při normálním protokolování.

import logging

from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureLogHandler())
# Alternatively, manually pass in the connection_string
# logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

properties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}

# Use properties in exception logs
try:
    result = 1 / 0  # generate a ZeroDivisionError
except Exception:
    logger.exception('Captured an exception.', extra=properties)

Vzhledem k tomu, že musíte explicitně protokolovat výjimky, je na vás, jak protokolovat neošetřené výjimky. OpenCensus neuvádí omezení, jak toto protokolování provést, ale musíte explicitně protokolovat telemetrii výjimek.

Odesílání událostí

Telemetrii můžete posílat customEvent úplně stejným způsobem, jakým odesíláte trace telemetrii, s výjimkou použití AzureEventHandler .

import logging
from opencensus.ext.azure.log_exporter import AzureEventHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureEventHandler())
# Alternatively manually pass in the connection_string
# logger.addHandler(AzureEventHandler(connection_string=<appinsights-connection-string>))

logger.setLevel(logging.INFO)
logger.info('Hello, World!')

Vzorkování

Informace o vzorkování v OpenCensus naleznete v tématu Vzorkování v OpenCensus.

Korelace protokolů

Informace o tom, jak rozšířit protokoly o kontextová data trasování, najdete v tématu Integrace protokolů Pythonu OpenCensus.

Úprava telemetrie

Informace o tom, jak upravit sledované telemetrie před odesláním do služby Azure Monitor, najdete v tématu Procesory telemetrie Pythonu OpenCensus.

Metriky

OpenCensus.stats podporuje čtyři metody agregace, ale poskytuje částečnou podporu pro Azure Monitor:

• Počet: Počet měrných bodů. Hodnota je kumulativní, může se zvyšovat a resetovat na 0 při restartování.
• Součet: Součet měrných bodů. Hodnota je kumulativní, může se zvyšovat a resetovat na 0 při restartování.
• LastValue: Zachová poslední zaznamenanou hodnotu a zahodí všechno ostatní.
• Distribuce: Vývozce Azure nepodporuje histogram rozdělení měrných bodů.

Příklad agregace počtu

1. Nejprve vygenerujme nějaká místní data metrik. Vytvoříme metriku, která bude sledovat, kolikrát uživatel vybere klávesu Enter .

   
   from datetime import datetime
   from opencensus.stats import aggregation as aggregation_module
   from opencensus.stats import measure as measure_module
   from opencensus.stats import stats as stats_module
   from opencensus.stats import view as view_module
   from opencensus.tags import tag_map as tag_map_module
   
   stats = stats_module.stats
   view_manager = stats.view_manager
   stats_recorder = stats.stats_recorder
   
   prompt_measure = measure_module.MeasureInt("prompts",
                                              "number of prompts",
                                              "prompts")
   prompt_view = view_module.View("prompt view",
                                  "number of prompts",
                                  [],
                                  prompt_measure,
                                  aggregation_module.CountAggregation())
   view_manager.register_view(prompt_view)
   mmap = stats_recorder.new_measurement_map()
   tmap = tag_map_module.TagMap()
   
   def main():
       for _ in range(4):
           mmap.measure_int_put(prompt_measure, 1)
           mmap.record(tmap)
           metrics = list(mmap.measure_to_view_map.get_metrics(datetime.utcnow()))
           print(metrics[0].time_series[0].points[0])
   
   if __name__ == "__main__":
       main()
   

2. Metriky se vytvářejí ke sledování mnohokrát. Při každé položce se hodnota zvýší a v konzole se zobrazí informace o metrikách. Informace zahrnují aktuální hodnotu a aktuální časové razítko při aktualizaci metriky.

   Point(value=ValueLong(5), timestamp=2019-10-09 20:58:04.930426)
   Point(value=ValueLong(6), timestamp=2019-10-09 20:58:05.170167)
   Point(value=ValueLong(7), timestamp=2019-10-09 20:58:05.438614)
   Point(value=ValueLong(7), timestamp=2019-10-09 20:58:05.834216)
   

3. Zadávání hodnot je užitečné pro demonstrační účely, ale chceme generovat data metrik do služby Azure Monitor. Předejte své připojovací řetězec přímo vývozci. Nebo ho můžete zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . Doporučujeme použít připojovací řetězec k vytvoření instance exportérů, kteří se používají k odesílání telemetrie do Application Insights. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   from datetime import datetime
   from opencensus.ext.azure import metrics_exporter
   from opencensus.stats import aggregation as aggregation_module
   from opencensus.stats import measure as measure_module
   from opencensus.stats import stats as stats_module
   from opencensus.stats import view as view_module
   from opencensus.tags import tag_map as tag_map_module
   
   stats = stats_module.stats
   view_manager = stats.view_manager
   stats_recorder = stats.stats_recorder
   
   prompt_measure = measure_module.MeasureInt("prompts",
                                              "number of prompts",
                                              "prompts")
   prompt_view = view_module.View("prompt view",
                                  "number of prompts",
                                  [],
                                  prompt_measure,
                                  aggregation_module.CountAggregation())
   view_manager.register_view(prompt_view)
   mmap = stats_recorder.new_measurement_map()
   tmap = tag_map_module.TagMap()
   
   exporter = metrics_exporter.new_metrics_exporter()
   # Alternatively manually pass in the connection_string
   # exporter = metrics_exporter.new_metrics_exporter(connection_string='<appinsights-connection-string>')
   
   view_manager.register_exporter(exporter)
   
   def main():
       for _ in range(10):
           input("Press enter.")
           mmap.measure_int_put(prompt_measure, 1)
           mmap.record(tmap)
           metrics = list(mmap.measure_to_view_map.get_metrics(datetime.utcnow()))
           print(metrics[0].time_series[0].points[0])
   
   if __name__ == "__main__":
       main()
   

4. Exportér odesílá data metrik do služby Azure Monitor v pevném intervalu. Tuto hodnotu musíte nastavit na 60 sekund, protože back-end Application Insights předpokládá agregaci bodů metrik v 60sekundovém časovém intervalu. Sledujeme jednu metriku, takže tato data metriky s libovolnou hodnotou a časovým razítkem, které obsahuje, se odesílají každý interval. Data jsou kumulativní, můžou se zvyšovat a resetovat na 0 při restartování.

   Data můžete najít v části customMetrics, ale customMetrics vlastnosti valueCount, valueSumvalueMin, , valueMaxa valueStdDev nejsou efektivně použity.

Nastavení vlastních dimenzí v metrikách

Sada OpenCensus Python SDK umožňuje přidat do telemetrie metrik vlastní dimenze pomocí tagsslovníku párů klíč-hodnota.

1. Vložte značky, které chcete použít, do mapy značek. Mapa značek funguje jako druh "fondu" všech dostupných značek, které můžete použít.

   ...
   tmap = tag_map_module.TagMap()
   tmap.insert("url", "http://example.com")
   ...
   

2. Pro určitou Viewhodnotu zadejte značky, které chcete použít při nahrávání metrik pomocí tohoto zobrazení prostřednictvím klíče značky.

   ...
   prompt_view = view_module.View("prompt view",
                               "number of prompts",
                               ["url"], # <-- A sequence of tag keys used to specify which tag key/value to use from the tag map
                               prompt_measure,
                               aggregation_module.CountAggregation())
   ...
   

3. Při zaznamenávání v mapě měření nezapomeňte použít mapu značek. Klíče značek zadané v mapě značek použité k záznamu View musí být nalezeny.

   ...
   mmap = stats_recorder.new_measurement_map()
   mmap.measure_int_put(prompt_measure, 1)
   mmap.record(tmap) # <-- pass the tag map in here
   ...
   

4. customMetrics V tabulce mají všechny záznamy metrik vygenerované pomocí prompt_view vlastních dimenzí {"url":"http://example.com"}.

5. Pokud chcete vytvořit značky s různými hodnotami pomocí stejných klíčů, vytvořte pro ně nové mapy značek.

   ...
   tmap = tag_map_module.TagMap()
   tmap2 = tag_map_module.TagMap()
   tmap.insert("url", "http://example.com")
   tmap2.insert("url", "https://www.wikipedia.org/wiki/")
   ...
   

Čítače výkonu

Ve výchozím nastavení exportér metrik odešle do služby Azure Monitor sadu čítačů výkonu. Tuto funkci můžete zakázat nastavením enable_standard_metrics příznaku v False konstruktoru vývozce metrik.

...
exporter = metrics_exporter.new_metrics_exporter(
  enable_standard_metrics=False,
  )
...

Aktuálně se odesílají následující čítače výkonu:

• Dostupná paměť (bajty)
• Čas procesoru procesoru (procento)
• Příchozí frekvence požadavků (za sekundu)
• Průměrná doba provádění příchozích požadavků (milisekundy)
• Využití procesoru procesu (procento)
• Zpracování privátních bajtů (bajtů)

Tyto metriky byste měli vidět v performanceCounters. Další informace naleznete v tématu Čítače výkonu.

Úprava telemetrie

Informace o tom, jak upravit sledované telemetrie před odesláním do služby Azure Monitor, najdete v tématu Procesory telemetrie Pythonu OpenCensus.

Sledování

1. Nejprve vygenerujme nějaká data trasování místně. V prostředí Python IDLE nebo editoru podle vašeho výběru zadejte následující kód:

   from opencensus.trace.samplers import ProbabilitySampler
   from opencensus.trace.tracer import Tracer
   
   tracer = Tracer(sampler=ProbabilitySampler(1.0))
   
   def main():
       with tracer.span(name="test") as span:
           for value in range(5):
               print(value)
   
   
   if __name__ == "__main__":
       main()
   

2. Při každé položce se hodnota vytiskne do prostředí. Modul OpenCensus Python vygeneruje odpovídající část .SpanData Projekt OpenCensus definuje trasování jako strom rozpětí.

   0
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='15ac5123ac1f6847', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:22.805429Z', end_time='2019-06-27T18:21:44.933405Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   1
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='2e512f846ba342de', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:44.933405Z', end_time='2019-06-27T18:21:46.156787Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   2
   [SpanData(name='test', context=SpanContext(trace_id=8aa41bc469f1a705aed1bdb20c342603, span_id=None, trace_options=TraceOptions(enabled=True), tracestate=None), span_id='f3f9f9ee6db4740a', parent_span_id=None, attributes=BoundedDict({}, maxlen=32), start_time='2019-06-27T18:21:46.157732Z', end_time='2019-06-27T18:21:47.269583Z', child_span_count=0, stack_trace=None, annotations=BoundedList([], maxlen=32), message_events=BoundedList([], maxlen=128), links=BoundedList([], maxlen=32), status=None, same_process_as_parent_span=None, span_kind=0)]
   

3. Zobrazení výstupu je užitečné pro demonstrační účely, ale chceme generovat SpanData do služby Azure Monitor. Předejte své připojovací řetězec přímo vývozci. Nebo ho můžete zadat v proměnné APPLICATIONINSIGHTS_CONNECTION_STRINGprostředí . Doporučujeme použít připojovací řetězec k vytvoření instance exportérů, kteří se používají k odesílání telemetrie do Application Insights. Upravte kód z předchozího kroku na základě následující ukázky kódu:

   from opencensus.ext.azure.trace_exporter import AzureExporter
   from opencensus.trace.samplers import ProbabilitySampler
   from opencensus.trace.tracer import Tracer
   
   tracer = Tracer(
       exporter=AzureExporter(),
       sampler=ProbabilitySampler(1.0),
   )
   # Alternatively manually pass in the connection_string
   # exporter = AzureExporter(
   #   connection_string='<appinsights-connection-string>',
   #   ...
   # )
   
   def main():
       with tracer.span(name="test") as span:
           for value in range(5):
               print(value)
   
   if __name__ == "__main__":
       main()
   

4. Když teď spustíte skript Pythonu, vytiskne se v prostředí jenom hodnota. SpanData Vytvoření se odešle do služby Azure Monitor. V části dependencies.

   Další informace o odchozích požadavcích najdete v tématu Závislosti Jazyka Python OpenCensus. Další informace o příchozích požadavcích najdete v tématu OpenCensus Python requests.

Vzorkování

Informace o vzorkování v OpenCensus naleznete v tématu Vzorkování v OpenCensus.

Trasování korelace

Další informace o korelaci telemetrie v datech trasování najdete v tématu OpenCensus Python Telemetry Correlation.

Úprava telemetrie

Další informace o tom, jak upravit sledované telemetrie před odesláním do služby Azure Monitor, najdete v tématu o procesorech telemetrie Pythonu OpenCensus.

Konfigurace exportérů služby Azure Monitor

Jak je vidět, existují tři různé exportéry služby Azure Monitor, které podporují OpenCensus. Každý z nich odesílá do Služby Azure Monitor různé typy telemetrie. Pokud chcete zjistit, jaké typy telemetrie každý vývozce odesílá, podívejte se do následující tabulky.

Každý vývozce přijímá stejné argumenty pro konfiguraci předané konstruktory. Informace o každé z nich najdete tady:

Integrace se službou Azure Functions

Pokud chcete zachytit vlastní telemetrii v prostředích Azure Functions, použijte rozšíření OpenCensus Python Azure Functions. Další informace najdete v příručce pro vývojáře v Pythonu pro Azure Functions.

Ověřování (Preview)

Každý z exportérů Azure Monitoru podporuje konfiguraci bezpečného odesílání datových částí telemetrie prostřednictvím ověřování OAuth pomocí Azure Active Directory. Další informace najdete v dokumentaci k ověřování.

Zobrazení dat pomocí dotazů

Telemetrická data odesílaná z vaší aplikace můžete zobrazit prostřednictvím karty Protokoly (Analytics).

V seznamu v části Aktivní:

• Pro telemetrii odesílanou exportérem trasování služby Azure Monitor se příchozí požadavky zobrazí v části requests. Odchozí nebo probíhající požadavky se zobrazí v části dependencies.
• U telemetrických dat odeslaných s exportérem metrik služby Azure Monitor se odeslané metriky zobrazí v části customMetrics.
• Pro telemetrii odesílanou exportérem protokolů služby Azure Monitor se protokoly zobrazí v části traces. Výjimky se zobrazí v části exceptions.

Další informace o používání dotazů a protokolů najdete v tématu Protokoly ve službě Azure Monitor.

Konfigurace a povolení ověřování založeného na ID microsoftu Entra

Vytvořte příslušné přihlašovací údaje a předejte je do konstruktoru vývozce služby Azure Monitor. Ujistěte se, že je váš připojovací řetězec nastavený pomocí instrumentačního klíče a koncového bodu příjmu dat vašeho prostředku.

Exportéři OpenCensus služby Azure Monitor podporují tyto typy ověřování. Doporučujeme používat spravované identity v produkčních prostředích.

Spravovaná identita přiřazená systémem

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential()
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Spravovaná identita přiřazená uživatelem

from azure.identity import ManagedIdentityCredential

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

credential = ManagedIdentityCredential(client_id="<client-id>")
tracer = Tracer(
    exporter=AzureExporter(credential=credential, connection_string="InstrumentationKey=<your-instrumentation-key>;IngestionEndpoint=<your-ingestion-endpoint>"),
    sampler=ProbabilitySampler(1.0)
)
...

Další informace o OpenCensus pro Python

• OpenCensus Python na GitHubu
• Vlastní nastavení
• Exportéři azure Monitoru na GitHubu
• Integrace OpenCensus
• Ukázkové aplikace služby Azure Monitor

Řešení problému

Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat

Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST do koncových bodů příjmu dat. Připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat můžete otestovat pomocí nezpracovaných klientů REST z příkazů PowerShellu nebo curl. Viz Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.

Poznámky k verzi

Nejnovější poznámky k verzi najdete v tématu Exportér služby Azure Monitor v Pythonu.

Naše aktualizace služeb také shrnují hlavní vylepšení Application Insights.

Další kroky

• Pokud chcete povolit používání, povolte monitorování uživatelů ve webovém nebo prohlížeči.
• Sledování příchozích požadavků
• Sledování odchozích požadavků
• Podívejte se na mapu aplikace.
• Naučte se provádět komplexní monitorování výkonu.

Výstrahy

• Přehled dostupnosti: Vytvořte testy, abyste měli jistotu, že je váš web viditelný na webu.
• Inteligentní diagnostika: Tyto testy se spouštějí automaticky, takže je nemusíte nijak nastavovat. Upozorní vás, pokud má aplikace nezvykle velký podíl neúspěšných požadavků.
• Upozornění na metriky: Nastavte upozornění, která vás upozorní, pokud metrika překročí prahovou hodnotu. Upozornění můžete nastavit u vlastních metrik, které v aplikaci naprogramujete.