Instrumentação personalizada via atributo (.NET)

O agente .NET da New Relic oferece diversas opções para instrumentação personalizada. A instrumentação personalizada permite instrumentar partes do seu aplicativo que não são instrumentadas automaticamente. Este documento descreve como instrumentar seu aplicativo decorando os métodos no código do seu aplicativo com atributo.

• Use o atributo Transaction para criar uma transação personalizada. Você também pode marcar a transação personalizada como uma transação da web com a propriedade Web do atributo.
• Use o atributo Trace para adicionar instrumentação personalizada a métodos invocados em uma transação preexistente.

Requisitos e recomendações

Os requisitos incluem:

• Agente .NET versão 6.16.178.0 ou superior.
• Você deve estar disposto a modificar seu código-fonte. Se você não pode ou não deseja modificar seu código-fonte, use instrumentação personalizada via XML.
• Seu projeto deve ter uma referência a NewRelic.Api.Agent.dll (por exemplo, instalar o pacote e colocar using NewRelic.Api.Agent; em seu código). Este pacote está na galeria do NuGet.
• O atributo Transaction e Trace devem ser aplicados a implementações concretas de métodos. Eles não podem ser aplicados em interfaces ou definições de métodos de superclasses.

Transação chamada transação dentro

Os métodos decorados com o atributo [Transaction] só criarão uma nova transação quando ainda não existir uma. Quando um método decorado com [Transaction] é chamado a partir de within uma transação iniciada anteriormente, ele será tratado como o atributo [Trace] e fornecerá mais informações sobre a transação existente.

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

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

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

Crie uma nova transação fora da web

Para iniciar uma transação fora da web (também conhecida como solicitação em segundo plano) com o atributo Transaction :

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

Para obter detalhes sobre por que usar web ou não-web, consulte Classificar como web ou não-web.

Crie uma nova transação da web

Para instruir o agente a marcar uma tarefa que não seja da Web como uma transação do browser da Web, use uma destas opções:

• Defina a propriedade Web do atributo Transaction como true.
• Defina o URI da transação com 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
}

Quando usado dentro de uma transação iniciada anteriormente, será tratado como um atributo [Trace] .

Para obter detalhes sobre por que usar web ou não-web, consulte Classificar como web ou não-web.

Adicione detalhes à transação existente com Trace

Se o seu trace da transação mostrar grandes blocos de tempo não instrumentado e você quiser incluir métodos adicionais no trace, você poderá usar o atributo Trace:

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

Propriedades para Transaction

O atributo Transaction oferece suporte às seguintes propriedades:

[Transaction(Web = true)]

Exemplo: instrumento quatro métodos

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();
                }
            }
        }
    }
}

Leia postagens do fórum sobre instrumentação

Para recomendações mais específicas, confira estas postagens em nossa comunidade do Fórum de Suporte:

• Solucionar problemas de instrumentação personalizada baseada em atributo
• Construir instrumentação personalizada tracer factorys from .NET agent arquivo de log

Use outras funções da API

Para obter mais informações sobre a API do agente .NET e sua funcionalidade, consulte o guia da API do agente .NET da New Relic. Para instrumentação personalizada sem modificar seu código-fonte, consulte Criar transação via XML e Adicionar detalhes à transação via XML.