Conseils et astuces Python

Afin de vous aider à tirer le meilleur parti de l'utilisation de l'agent Python pour monitorer votre application Web, voici quelques trucs et astuces.

Décorateurs et introspection

Lors de la dénomination d'une transaction ou d'un nœud de trace de fonction, l'agent Python doit introspecter le nom de la fonction appelée. Lorsque la fonction est une fonction brute ou une méthode de classe, tout fonctionne correctement. Toutefois, si un décorateur a été appliqué à la fonction ou à la méthode de classe, si le décorateur n'a pas été implémenté pour préserver la capacité d'introspecter la fonction encapsulée, alors l'agent utilisera le nom de la fonction encapsulée du décorateur au lieu de la fonction encapsulée.

La manière typique dont un décorateur est implémenté est d'utiliser le modèle :

def decorator(f):
    def _decorator():
        f()
    return _decorator

@decorator
def foo():
    pass

Le problème avec cette implémentation est que si nous regardons la valeur de foo.__name__ , ce sera _decorator et non foo. Si le décorateur est contenu dans un module séparé, en regardant foo.__module__ , ce sera le nom du module dans lequel le décorateur est déclaré et non le nom du module dans lequel la fonction encapsulée est contenue.

Afin de garantir que les modules et les fonctions sont nommés correctement, utilisez le décorateur wraps() du module functools de la bibliothèque standard pour encapsuler la fonction de décorateur interne :

import functools

def decorator(f):
    @functools.wraps(f)
    def _decorator():
        f()
    return _decorator

@decorator
def foo():
    pass

Pour plus d'informations, consultez la documentation de la fonction wraps() sur le site Web Python.

Identifier une transaction

Lorsque l'agent Python enregistre les détails d'erreur d'une transaction ou capture une trace de transaction lente, il n'existe aucun identifiant unique que vous pourriez capturer pour essayer de l'utiliser pour le corréler avec d'autres données que vous pouvez enregistrer séparément pour la transaction Cela rend difficile la correspondance des informations de l'UI avec le logging de votre propre application Web, par exemple.

Si vous souhaitez pouvoir effectuer une telle correspondance croisée, ou simplement capturer par rapport à une transaction des détails supplémentaires qui peuvent être utiles dans cette situation, vous pouvez utiliser l'API d'agent pour enregistrer des paramètres personnalisés par rapport à la transaction. Si une erreur se produit ou si une trace de transaction lente est enregistrée, qui est ensuite affichée dans l'UI, les paramètres supplémentaires que vous fournissez seront alors affichés sous la section Custom parameters des détails de l'erreur ou trace .

Pour ajouter de tels détails supplémentaires, vous pouvez utiliser la fonction add_custom_attribute() dans le module newrelic.agent .

Prenons par exemple le code suivant de l’application polls dans le didacticiel du framework Web Django.

from django.shortcuts import render_to_response, get_object_or_404

def detail(request, poll_id):
    p = get_object_or_404(Poll, pk=poll_id)
    return render_to_response('polls/detail.html', {'poll': p})

Si vous souhaitez enregistrer l'ID d'interrogation par rapport à la transaction afin qu'il soit disponible en cas de problème, vous devez utiliser :

import newrelic.agent

def detail(request, poll_id):
    newrelic.agent.add_custom_attribute('poll_id', poll_id)
    p = get_object_or_404(Poll, pk=poll_id)
    return render_to_response('polls/detail.html', {'poll': p})

La valeur utilisée pour un paramètre personnalisé peut être n'importe quelle valeur pouvant être sérialisée par l'encodeur JSON fourni par le module json . Cela inclut les tuples, les listes et les dictionnaires.

Recommandation : limitez les valeurs aux valeurs entières, flottantes ou de chaîne. Si vous utilisez des structures de données plus complexes, évitez d'essayer d'associer une structure de données trop volumineuse, car elle devra être mise en cache jusqu'à ce qu'elle soit récoltée, empaquetée puis envoyée à l'application principale.

Les valeurs simples sont également préférées, car si la valeur ne peut pas être sérialisée en JSON, les détails de l'erreur ou la transaction lente peuvent être ignorés.

Enregistrement métriques personnalisé

Nous ne pouvons instrumenter que les modules tiers accessibles au public pour Python que nous connaissons. Pour étendre l’instrumentation de votre propre code, utilisez les techniques décrites dans Ajout d’instrumentation Python. Cela vous donnera une couverture des données de répartition des performances pour le Web des transactions et un suivi lent des transactions.

Vous pouvez enregistrer des données de performances arbitraires via un appel d'API (par exemple : données de synchronisation ou de ressources informatiques). Utilisez ensuite métriques et événement pour créer des graphiques et suivre cette métrique. Vous pouvez utiliser des métriques personnalisées pour unifier votre monitoring.

Pour enregistrer des métriques personnalisées, utilisez la fonction record_custom_metric() dans le module newrelic.agent . Il faut deux arguments, le nom de la métrique et la valeur. La valeur doit être un entier ou une valeur à virgule flottante.

import newrelic.agent

def create_account(request, ...):
    ...
    newrelic.agent.record_custom_metric('Custom/Signups', 1)
    ...
    return render_to_response('...', ...)

Démarrez le chemin du nom de métrique Custom/ pour éviter les collisions d'espace de nommage avec les métriques d'agent existantes (par exemple, Custom/MyMetric).

Les métriques personnalisées seront agrégées sur chaque cycle de collecte puis envoyées au collecteur. Dans ce cas, chaque 1 sera additionné pour enregistrer le nombre d'inscriptions dans le cycle de collecte.

Bien que l'instrumentation de trace de fonction soit utilisée pour suivre les appels de fonction ou le temps passé dans un bloc de code, elle ne permet pas de créer des graphiques personnalisés distincts. Les métriques personnalisées peuvent toujours être utilisées pour enregistrer et tracer le temps lié à la durée de quelque chose.

Pour faciliter cette opération, vous pouvez prédéfinir une classe de gestionnaire de contexte pour la synchronisation et l'enregistrement de la métrique.

class CustomMetricTimedNode(object):

    def __init__(self, name):
        self.name = name
        self.start_time = None
        self.end_time = None

    def __enter__(self):
        self.start_time = time.time()
        return self

    def __exit__(self, exc, value, tb):
        if not self.start_time:
            return
        self.end_time = time.time()
        duration = self.end_time - self.start_time
        newrelic.agent.record_custom_metric(self.name, duration)

Cela peut ensuite être utilisé en conjonction avec une instruction with autour d'un bloc de code.

def function():
    with CustomMetricTimedNode('Custom/TimedNode1'):
        time.sleep(0.01)

Le gestionnaire de contexte pourrait être appliqué aux fonctions en créant un décorateur de fonction.

def custom_metric_timed_node(name):
    def _decorator(f):
        @functools.wraps(f)
        def _wrapper(*args, **kwargs):
            with CustomMetricTimedNode(name):
                return f(*args, **kwargs)
        return _wrapper
    return _decorator

avec lui étant utilisé comme :

@custom_metric_timed_node('Custom/TimedNode2')
def function():
    time.sleep(0.01)

Comme lors de l'ajout instrumentation pour le traçage de fonctions, il est recommandé de choisir des noms métriques dans un ensemble fini et de longueur relativement petite. Vous devez éviter les noms dont la valeur est illimitée, sinon leur volume rend difficile leur affichage de manière significative. Un grand nombre de noms uniques peut également entraîner une utilisation excessive de la mémoire et la normalisation forcée de vos noms par l'agent pour limiter le nombre de noms uniques.