Configurer Azure Monitor pour votre application Python

Notes

Le Kit de développement logiciel (SDK) Python OpenCensus est déconseillé, mais Microsoft le prend en charge jusqu’à sa mise hors service le 30 septembre 2024. Nous recommandons l’offre Python basée sur OpenTelemetry et fournissons des conseils de migration.

Azure Monitor prend en charge le traçage distribué, la collecte de métriques et la journalisation des applications Python.

La solution prise en charge par Microsoft pour le suivi et l’exportation des données pour vos applications Python consiste à utiliser le SDK Python OpenCensus par le biais des exportateurs Azure Monitor.

Microsoft ne recommande pas d’utiliser d’autres kits SDK de télémétrie pour Python comme solution de télémétrie, car ils ne sont pas pris en charge.

OpenCensus est en train de converger vers OpenTelemetry. Nous continuons à recommander OpenCensus pendant que OpenTelemetry progresse.

Prérequis

Vous avez besoin d’un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Notes

Le support de l’ingestion de clé d’instrumentation prendra fin le 31 mars 2025. L’ingestion de clé d’instrumentation continuera de fonctionner, mais nous ne fournirons plus de mises à jour ni de support pour la fonctionnalité. Passez aux chaînes de connexion pour tirer parti des nouvelles fonctionnalités.

Présentation du SDK Python OpenCensus

OpenCensus est un ensemble de bibliothèques open source permettant de collecter des données de télémétrie distribuées sur le traçage, les métriques et la journalisation. À l’aide des exportateurs Azure Monitor, vous pouvez envoyer ces données de télémétrie collectées à Application Insights. Cet article vous guide pas à pas pour configurer OpenCensus et les exportateurs Azure Monitor pour Python afin d’envoyer vos données de monitoring à Azure Monitor.

Instrumentation à l’aide du Kit de développement logiciel (SDK) OpenCensus Python pour Azure Monitor

Installez les exportateurs OpenCensus Azure Monitor comme suit :

python -m pip install opencensus-ext-azure

Le kit SDK utilise trois exportateurs Azure Monitor pour envoyer différents types de données de télémétrie à Azure Monitor. Il s’agit de trace, metrics et logs. Pour plus d’informations sur ces types de données de télémétrie, consultez la vue d’ensemble de la plateforme de données. Utilisez les instructions suivantes pour envoyer ces types de télémétrie par le biais des trois exportateurs.

Mappages des types de données de télémétrie

OpenCensus mappe les exportateurs suivants aux types de données de télémétrie que vous voyez dans Azure Monitor.

Pilier de l’observabilité	Type de données de télémétrie dans Azure Monitor	Explication
Journaux d’activité	Traces, exceptions, customEvents	Données de télémétrie de journaux, d’exceptions, d’événements
Mesures	customMetrics, performanceCounters	Métriques personnalisées, conteurs de performances
Suivi	Requêtes, dépendances	Requêtes entrantes, requêtes sortantes

Journaux d’activité

1. Commençons par générer des données de journal locales.

   
   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. Une entrée de journal est émise pour chaque nombre de la plage.

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

3. Nous voulons voir ces données de journal dans Azure Monitor. Vous pouvez la spécifier dans une variable d’environnement, APPLICATIONINSIGHTS_CONNECTION_STRING. Vous pouvez également passer connection_string directement à AzureLogHandler, mais les chaînes de connexion ne doivent pas être ajoutées à la gestion de versions.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>
   

   Nous recommandons d'utiliser la chaîne de connexion pour instancier les exportateurs servant à envoyer les données de télémétrie à Application Insights. Modifiez le code de l’étape précédente sur la base de l’exemple de code suivant :

   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. L’exportateur envoie les données de journal à Azure Monitor. Vous pouvez trouver les données sous traces.

   Dans ce contexte, traces n’est pas identique à tracing. Ici, traces fait référence au type de télémétrie que vous voyez dans Azure Monitor quand vous utilisez AzureLogHandler. Or, tracing fait référence à un concept dans OpenCensus et se rapporte au suivi distribué.

   Notes

   L’enregistreur d’événements racine est configuré avec le niveau warning. Cela signifie que tous les journaux que vous envoyez dont le niveau de gravité est inférieur sont ignorés et, à leur tour, ne sont pas envoyés à Azure Monitor. Pour plus d’informations, consultez la documentation sur la journalisation.

5. Vous pouvez aussi ajouter des propriétés personnalisées à vos messages de journal dans l’argument de mot clé extra en utilisant le champ custom_dimensions. Ces propriétés se présentent sous forme de paires clé-valeur dans customDimensions, dans Azure Monitor.

   Notes

   Pour que cette fonctionnalité fonctionne, vous devez passer un dictionnaire au champ custom_dimensions. Si vous passez des arguments de tout autre type, l’enregistreur d’événements les ignore.

   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)
   

Notes

Dans le cadre de l’utilisation de l’instrumentation Application Insights, nous collectons et envoyons des données de diagnostic à Microsoft. Ces données nous permettent d’exécuter et d’améliorer Application Insights. Vous avez la possibilité de désactiver la collecte de données non essentielles. Pour en savoir plus, consultez Statsbeat dans Application Insights.

Configurer la journalisation pour les applications Django

Vous pouvez configurer explicitement la journalisation dans votre code d’application comme dans l’exemple précédent pour vos applications Django, ou vous pouvez la spécifier dans la configuration de la journalisation Django. Ce code peut être placé dans l’un des fichiers que vous utilisez pour la configuration des paramètres de site Django, généralement settings.py.

Pour plus d’informations sur la manière de configurer les paramètres Django, consultez Paramètres Django. Pour plus d’informations sur la configuration de la journalisation, consultez Journalisation Django.

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"]},
    },
}

Veillez à utiliser l’enregistreur d’événements dont le nom est le même que celui spécifié dans votre configuration.

# views.py

import logging
from django.shortcuts import request

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

Envoyer les exceptions

OpenCensus Python ne suit pas et n’envoie pas automatiquement les données de télémétrie exception. Elles sont envoyées par le biais de AzureLogHandler en utilisant les exceptions de la bibliothèque de journalisation Python. Vous pouvez ajouter des propriétés personnalisées comme vous le faites pour une journalisation normale.

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)

Sachant que vous devez journaliser les exceptions de manière explicite, il vous appartient de décider comment journaliser les exceptions non gérées. OpenCensus n’impose pas de restrictions sur la façon d’effectuer cette journalisation, mais vous devez consigner explicitement les données de télémétrie des exceptions.

Envoyer des événements

Vous pouvez envoyer des données de télémétrie customEvent exactement de la même façon que vous envoyez les données de télémétrie trace, à ceci près que vous devez plutôt utiliser 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!')

échantillonnage

Pour plus d’informations sur l’échantillonnage dans OpenCensus, consultez Échantillonnage dans OpenCensus.

Corrélation des journaux

Pour plus d’informations sur l’enrichissement de vos journaux avec des données de contexte de trace, consultez Intégration de journaux Python OpenCensus.

Modifier la télémétrie

Pour savoir comment modifier les données de télémétrie suivies avant leur envoi à Azure Monitor, consultez Processeurs de télémétrie OpenCensus Python.

Mesures

OpenCensus.stats prend en charge quatre méthodes d’agrégation, mais fournit une prise en charge partielle pour Azure Monitor :

• Count : Nombre de points de mesure. La valeur est cumulative, elle peut uniquement augmenter et elle est remise à 0 au redémarrage.
• Sum : Somme des points de mesure. La valeur est cumulative, elle peut uniquement augmenter et elle est remise à 0 au redémarrage.
• LastValue : Conserve la dernière valeur enregistrée et supprime tout le reste.
• Distribution: L’exportateur Azure ne prend pas en charge la distribution des points de mesure de l’histogramme.

Exemple d’agrégation Count

1. Commençons par générer des données de métrique locales. Nous créons une métrique pour suivre le nombre de fois que l’utilisateur appuie sur la touche Entrée.

   
   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. Les métriques sont créées pour effectuer le suivi de nombreuses fois. À chaque entrée, la valeur est incrémentée et les informations de la métrique s’affichent dans la console. Les informations incluent la valeur actuelle et l’horodatage en cours au moment de la mise à jour de la métrique.

   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. Entrer des valeurs s’avère utile à des fins de démonstration, mais nous voulons émettre les données de métrique vers Azure Monitor. Passez votre chaîne de connexion directement à l’exportateur. Vous pouvez aussi la spécifier dans une variable d’environnement, APPLICATIONINSIGHTS_CONNECTION_STRING. Nous recommandons d'utiliser la chaîne de connexion pour instancier les exportateurs servant à envoyer les données de télémétrie à Application Insights. Modifiez le code de l’étape précédente sur la base de l’exemple de code suivant :

   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. L’exportateur envoie les données de métrique à Azure Monitor à intervalle fixe. Vous devez définir cette valeur sur 60 secondes, car le back-end Application Insights suppose l’agrégation des points de métriques sur un intervalle de 60 secondes. Nous effectuons le suivi d’une seule métrique, de sorte que les données de cette métrique, quels que soient la valeur et l’horodatage qu’elles contiennent, sont envoyées à chaque intervalle. Les données sont cumulatives, peuvent uniquement augmenter et sont remises à 0 au redémarrage.

   Vous pouvez trouver les données sous customMetrics, mais les propriétés customMetricsvalueCount, valueSum, valueMin, valueMax et valueStdDev ne sont pas utilisées efficacement.

Définir des dimensions personnalisées dans les métriques

Le SDK Python OpenCensus vous permet d’ajouter des dimensions personnalisées à votre télémétrie de métriques en utilisant des tags, qui s’apparentent à un dictionnaire de paires clé-valeur.

1. Insérez les étiquettes que vous souhaitez utiliser dans la carte des étiquettes. Cette carte agit comme une sorte de « pool » de toutes les étiquettes que vous pouvez utiliser.

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

2. Pour un objet View spécifique, spécifiez les étiquettes à utiliser lors de l’enregistrement des métriques avec cette vue par le biais de la clé d’étiquette.

   ...
   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. Veillez à utiliser la carte des étiquettes lors d’un enregistrement dans la carte de mesure. Les clés d’étiquettes spécifiées dans l’objet View doivent se trouver dans la carte des étiquettes utilisée pour l’enregistrement.

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

4. Sous la table customMetrics, tous les enregistrements de métriques émis à l’aide de prompt_view ont des dimensions personnalisées {"url":"http://example.com"}.

5. Pour produire des étiquettes avec des valeurs différentes à l’aide des mêmes clés, créez des cartes d’étiquettes pour elles.

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

Compteurs de performance

Par défaut, l’exportateur de métriques envoie un ensemble de compteurs de performances à Azure Monitor. Vous pouvez désactiver cette fonctionnalité en définissant l’indicateur enable_standard_metrics sur False dans le constructeur de l’exportateur de métriques.

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

Les compteurs de performances actuellement envoyés sont les suivants :

• Mémoire disponible (en octets)
• Temps processeur UC (en pourcentage)
• Taux de requêtes entrantes (par seconde)
• Durée moyenne d’exécution de la requête entrante (en millisecondes)
• Utilisation du processeur UC (en pourcentage)
• Octets privés de processus (en octets)

Vous devriez être en mesure de voir ces métriques dans performanceCounters. Pour plus d’informations, consultez Compteurs de performances.

Modifier la télémétrie

Pour savoir comment modifier les données de télémétrie suivies avant leur envoi à Azure Monitor, consultez Processeurs de télémétrie OpenCensus Python.

Traçage

Notes

Dans OpenCensus, tracing fait référence au suivi distribué. Le paramètre AzureExporter envoie des données de télémétrie requests et dependency à Azure Monitor.

1. Commençons par générer des données de trace en local. Dans IDLE de Python ou dans l’éditeur de votre choix, saisissez le code suivant :

   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. À chaque entrée, la valeur est imprimée dans l’interpréteur de commandes. Le module Python OpenCensus génère un élément correspondant de SpanData. Le projet OpenCensus définit une trace comme une arborescence d’étendues.

   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. L’affichage de la sortie s’avère utile à des fins de démonstration, mais nous voulons émettre des SpanData sur Azure Monitor. Passez votre chaîne de connexion directement à l’exportateur. Vous pouvez aussi la spécifier dans une variable d’environnement, APPLICATIONINSIGHTS_CONNECTION_STRING. Nous recommandons d'utiliser la chaîne de connexion pour instancier les exportateurs servant à envoyer les données de télémétrie à Application Insights. Modifiez le code de l’étape précédente sur la base de l’exemple de code suivant :

   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. Maintenant, lorsque vous exécutez le script Python, seule la valeur est en cours d’impression dans l’interpréteur de commandes. Le SpanData créé est envoyé à Azure Monitor. Vous pouvez trouver les données d’unités de travail émises sous dependencies.

   Pour plus d’informations sur les requêtes sortantes, consultez les dépendances OpenCensus Python. Pour plus d’informations sur les requêtes entrantes, consultez les requêtes OpenCensus Python.

échantillonnage

Pour plus d’informations sur l’échantillonnage dans OpenCensus, consultez Échantillonnage dans OpenCensus.

Corrélation de trace

Pour plus d’informations sur la corrélation des données de télémétrie dans vos données de trace, consultez Corrélation des données de télémétrie Python OpenCensus.

Modifier la télémétrie

Pour plus d’informations sur la modification des données de télémétrie suivies avant leur envoi à Azure Monitor, consultez Processeurs de télémétrie OpenCensus Python.

Configurer les exportateurs Azure Monitor

Comme indiqué, les exportateurs Azure Monitor qui prennent en charge OpenCensus sont au nombre de trois. Chacun envoie différents types de données de télémétrie à Azure Monitor. Pour connaître les types des données de télémétrie envoyées par chaque exportateur, consultez le tableau suivant.

Chaque exportateur accepte les mêmes arguments de configuration passés par les constructeurs. Des informations sur chacun d’eux figurent ici :

Données de télémétrie d’exportateur	Description
connection_string	chaîne de connexion utilisée pour se connecter à votre ressource Azure Monitor. Est prioritaire sur instrumentation_key.
credential	Classe d’informations d’identification utilisée par l’authentification Azure Active Directory. Consultez la section « Authentification » qui suit.
enable_standard_metrics	Utilisé pour AzureMetricsExporter. Indique à l’exportateur d’envoyer automatiquement les métriques du compteur de performances à Azure Monitor. La valeur par défaut est True.
export_interval	sert à spécifier la fréquence d’exportation en secondes. La valeur par défaut est 15s. Pour les métriques, vous DEVEZ définir cette valeur sur 60 secondes, sinon vos agrégations de métriques n’ont pas de sens dans Metrics Explorer.
grace_period	Utilisé pour spécifier le délai d’expiration (en secondes) pour l’arrêt des exportateurs. La valeur par défaut est 5s.
instrumentation_key	clé d’instrumentation utilisée pour se connecter à votre ressource Azure Monitor.
logging_sampling_rate	Utilisé pour AzureLogHandler et AzureEventHandler. Fournit un taux d’échantillonnage [de 0 à 1,0] pour l’exportation des journaux/événements. La valeur par défaut est 1.0.
max_batch_size	spécifie la taille maximale des données de télémétrie exportées simultanément.
proxies	spécifie la séquence de proxys à utiliser pour l’envoi des données à Azure Monitor. Pour plus d'informations, consultez proxies.
storage_path	chemin d’accès au dossier de stockage local (données de télémétrie non envoyées). À partir de opencensus-ext-azure v1.0.3, le chemin par défaut est le répertoire temp du système d’exploitation + opencensus-python + your-ikey. Avant v1.0.3, le chemin par défaut est $USER + .opencensus + .azure + python-file-name.
timeout	Spécifie le délai d’expiration (en secondes) du réseau pour envoyer la télémétrie au service d’ingestion. La valeur par défaut est 10s.

Intégration à Azure Functions

Pour capturer des données de télémétrie personnalisées dans des environnements Azure Functions, utilisez l’extension Azure Functions Python OpenCensus. Pour plus d'informations, consultez le Guide du développeur Python sur Azure Functions.

Authentification (préversion)

Notes

La fonctionnalité d’authentification est disponible à partir de opencensus-ext-azure v1.1b0.

Chacun des exportateurs Azure Monitor prend en charge la configuration de l’envoi sécurisé de charges utiles de télémétrie par le biais d’une authentification OAuth auprès d’Azure Active Directory (AAD). Pour plus d’informations, consultez la documentation sur l’authentification.

Voir vos données avec des requêtes

Vous pouvez voir les données de télémétrie envoyées à partir de votre application via l’onglet Journaux (Analytics) .

Dans la liste sous Activé :

• Pour les données de télémétrie envoyées avec l’exportateur de traces Azure Monitor, les requêtes entrantes s’affichent sous requests. Les requêtes sortantes ou In-process s’affichent sous dependencies.
• Pour la télémétrie envoyée avec l’exportateur de métriques Azure Monitor, les métriques envoyées s’affichent sous customMetrics.
• Pour la télémétrie envoyée avec l’exportateur de journaux Azure Monitor, les journaux envoyés s’affichent sous traces. Les exceptions s’affichent sous exceptions.

Pour plus d’informations sur l’utilisation des requêtes et des journaux, consultez Journaux dans Azure Monitor.

En savoir plus sur OpenCensus pour Python

• OpenCensus Python sur GitHub
• Personnalisation
• Exportateurs Azure Monitor sur GitHub
• Intégrations OpenCensus
• Exemples d’applications Azure Monitor

Résolution des problèmes

Tester la connectivité entre votre hôte d’application et le service d’ingestion

Les SDK et les agents Application Insights envoient de la télémétrie à ingérer en tant qu’appels REST à nos points de terminaison d’ingestion. Vous pouvez tester la connectivité de votre serveur web ou de votre machine hôte d’application vers les points de terminaison de service d’ingestion en utilisant des clients du Representational State Transfer (REST) bruts à partir de commandes PowerShell ou curl. Consultez Résoudre les problèmes de télémétrie d’application manquante dans Azure Monitor Application Insights.

Notes de publication

Pour accéder aux dernières notes de publication, consultez Python Azure Monitor Exporter.

Nos Mises à jour de service résument également les principales améliorations apportées à Application Insights.

Étapes suivantes

• Pour activer les expériences d’utilisation, consultez Activer la supervision des utilisateurs web ou du navigateur
• Suivre les demandes entrantes.
• Suivre les demandes sortantes.
• Extraire le Plan de l’application.
• Découvrez comment effectuer un monitoring des performances de bout en bout.

Alertes

• Vue d’ensemble de la disponibilité : créez des tests pour vérifier que votre site est visible sur le web.
• Diagnostics intelligents : ces tests s’exécutent automatiquement, sans que vous n’ayez rien à faire pour les configurer. Ils vous indiquent si votre application affiche un taux inhabituel de demandes ayant échoué.
• Alertes de métriques : Définissez des alertes qui vous avertissent si un indicateur de performance dépasse un seuil. Vous pouvez définir des mesures personnalisées que vous codez dans votre application.