Instrumentation personnalisée via attribut (.NET)

L'agent .NET de New Relic fournit plusieurs options pour l'instrumentation personnalisée. instrumentation personnalisée vous permet d'instrumenter des parties de votre application qui ne sont pas instrumentées automatiquement. Ce document décrit comment instrumenter votre application en décorant les méthodes de votre code d'application avec un attribut.

• Utilisez l’attribut Transaction pour créer une transaction personnalisée. Vous pouvez également marquer la transaction personnalisée comme une transaction Web avec la propriété Web de l'attribut.
• Utilisez l’attribut Trace pour ajouter une instrumentation personnalisée aux méthodes appelées dans une transaction préexistante.

Exigences et recommandations

Les exigences comprennent :

• Agent .NET version 6.16.178.0 ou supérieure.
• Vous devez être prêt à modifier votre code source. Si vous ne pouvez pas ou ne voulez pas modifier votre code source, utilisez une instrumentation personnalisée via XML.
• Votre projet doit avoir une référence à NewRelic.Api.Agent.dll (par exemple, en installant le package et en plaçant using NewRelic.Api.Agent; dans votre code). Ce package se trouve dans la galerie NuGet.
• Les attributs Transaction et Trace doivent être appliqués aux implémentations concrètes des méthodes. Ils ne peuvent pas être appliqués aux interfaces ou aux définitions de méthodes de super-classe.
• Évitez les méthodes de niveau supérieur instrumentées telles que Main(), car ces méthodes ne se terminent pas tant que l'application n'est pas terminée, ce qui peut empêcher l'envoi de données à New Relic.

Transactions appelées dans les transactions

Les méthodes décorées avec l'attribut [Transaction] ne créeront une nouvelle transaction que si elle n'existe pas déjà. Lorsqu'une méthode décorée avec [Transaction] est appelée à partir de within une transaction précédemment démarrée, elle sera traitée comme l'attribut [Trace] et fournira plus d'informations sur la transaction existante.

static void Main(string[] args)
{
    OuterMethod();
}

[Transaction]
public void OuterMethod()
{
    InnerMethod();
}

[Transaction]
public void InnerMethod()
{
    // inner method code
}

Créer une nouvelle transaction non Web

Pour démarrer une transaction non Web (également appelée demande d'arrière-plan) avec l'attribut Transaction :

[Transaction]
public void Run()
{
    // your background task
}

Pour plus de détails sur les raisons pour lesquelles utiliser Web ou non-Web, voir Classer comme Web ou non-Web.

Créer un nouveau site Web de transaction

Pour indiquer à l'agent de marquer une tâche non Web comme une transaction de navigateur Web, utilisez l'une de ces options :

• Définissez la propriété Web de l’attribut Transaction sur true.
• Définissez l'URI de la transaction avec SetTransactionUri().

[Transaction(Web = true)]
public void Run()
{
    var uri = new Uri("https://www.mydomain.com/path");
    NewRelic.Api.Agent.NewRelic.SetTransactionUri(uri);

    // your web task
}

Lorsqu'il est utilisé dans une transaction précédemment démarrée, il sera traité comme un attribut [Trace] .

Pour plus de détails sur les raisons pour lesquelles utiliser Web ou non-Web, voir Classer comme Web ou non-Web.

Ajoutez des détails aux transactions existantes avec Trace

Si votre trace de transaction montre de grands blocs de temps non instrumentés et que vous souhaitez inclure des méthodes supplémentaires dans la trace, vous pouvez utiliser l'attribut Trace :

[Trace]
protected void MethodWithinTransaction()
{
    // your app code
}

Propriétés pour Transaction

L'attribut Transaction prend en charge les propriétés suivantes :

[Transaction(Web = true)]

Exemple : instrumenter quatre méthodes

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            var test = new MyClass();
            test.Method1(); // Creates a transaction named Method1 in the Web category.
            test.Method2(); // Creates a transaction named Method2 in the Custom category.
            test.Method3(); // Creates a transaction named Method3 in the Custom category.

            // Method4 won't create a new transaction, 
            // only add a segment to an existing transaction
            test.Method4();
        }
    }

    public class MyClass
    {
        // The agent creates a Web transaction that includes an external service 
        // request in its transaction traces.
        [Transaction(Web = true)]
        public void Method1()
        {
            new WebClient().DownloadString("https://www.google.com/");
        }

        // Creates a Custom transaction containing one segment.
        [Transaction]
        public void Method2()
        {
            // The Method3 segment will be created
            Method3();

            // The Method4 segment will contain your SQL query inside of it and 
            // possibly an execution plan.
            Method4();
        }

        // Method3 will be appear as a segment when called in Method2()
        // but will create a transaction when called directly in Main()
        [Transaction]
        public void Method3()
        {
            Thread.Sleep(1000);
        }

        // When Method4 is called directly in Main() the agent will not create a transaction.
        // However, when Method4 is called from Method2, Method4 will 
        // appear as a segment containing its SQL query.
        [Trace]
        public void Method4()
        {
            using (var connection = new SqlConnection(ConnectionStrings["MsSqlConnection"].ConnectionString))
            {
                connection.Open();
                using (var command = new SqlCommand("SELECT * FROM table", connection))
                using (var reader = command.ExecuteReader())
                {
                    reader.Read();
                }
            }
        }
    }
}

Lire les messages du forum sur l'instrumentation

Pour des recommandations plus spécifiques, consultez ces publications dans notre communauté du forum d'assistance :

• Résoudre les problèmes instrumentation personnalisée basée sur les attributs
• Construire des usines de traceur personnalisées instrumentation à partir d'agent .NET fichier de log

Utiliser d’autres fonctions API

Pour en savoir plus sur l'API d'agent .NET et ses fonctionnalités, consultez le guide d'API d'agent .NET de New Relic. Pour une instrumentation personnalisée sans modifier votre code source, consultez Créer des transactions via XML et Ajouter des détails aux transactions via XML.