Segmentos do instrumento Go

Com o New Relic for Go, você pode monitor os segmentos específicos de uma transação em um aplicativo Go para obter mais detalhes sobre funções específicas ou blocos de código.

Meça o tempo para funções e blocos de código

Segments são as partes específicas de uma transação em um aplicativo. Por segmentos instrumentados, você pode medir o tempo gasto por funções e blocos de código, como chamadas externas, chamadas de armazenamento de dados, adição de mensagens a filas e tarefas em segundo plano.

Example: Você tem uma transação associada a um processo de checkout, que processa informações de envio e de cartão de crédito. Você poderia instrumentar seu aplicativo para dividir essa transação em duas partes: um segmento para envio e um segmento para pagamento.

Segmentos de bloco de código

Depois de instrumentar uma transação, você estará pronto para instrumentar um ou mais segmentos dessa transação.

Para instrumentalizar um bloco arbitrário de código como um segmento, use o seguinte padrão e inclua txn como o nome da variável definida para a transação:

segment := newrelic.Segment{}
segment.Name = "mySegmentName"
segment.StartTime = txn.StartSegmentNow()
// ... code you want to time here ...
segment.End()

StartSegment é um ajudante conveniente. Ele cria um segmento e o inicia:

segment := txn.StartSegment("mySegmentName")
// ... code you want to time here ...
segment.End()

Segmentos de função

Instrumentado uma função como segmento é essencialmente o mesmo que instrumentado um bloco arbitrário de código como segmento. A principal diferença é que, como uma função tem um final discreto, você pode usar a instrução defer de Go.

Para utilizar uma função como segmento, adicione o seguinte código no início da função e inclua txn como o nome da variável definida para a transação:

defer txn.StartSegment("mySegmentName").End()

Segmentos de ninho

Os segmentos podem ser aninhados. O segmento que está sendo finalizado deve ser o segmento iniciado mais recentemente.

Aqui está um exemplo de um segmento começando e terminando dentro de outro segmento:

s1 := txn.StartSegment("outerSegment")
s2 := txn.StartSegment("innerSegment")
// s2 must end before s1
s2.End()
s1.End()

Um segmento de valor zero pode ser encerrado com segurança. Portanto, o código a seguir é seguro mesmo se a condicional falhar:

var s newrelic.Segment
if recordSegment {
    s.StartTime = txn.StartSegmentNow()
}
// ... code you wish to time here ...
s.End()

Segmentos do armazenamento de dados

Você pode fazer chamadas de armazenamento de dados do aplicativo Instrumento Go. Os segmentos do armazenamento de dados aparecem na tabela Transactions breakdown do APM e na guia Databases da páginaTransactions no New Relic.

Se você estiver usando um driver MySQL, PostgreSQL ou SQLite do banco de dados, a maneira mais fácil de adicionar segmentos de armazenamento de dados é usar nossos pacotes de integração pré-construídos. Caso contrário, você poderá criar manualmente segmentos de armazenamento de dados para cada chamada de banco de dados.

import (
    // import our integration package in place of "github.com/go-sql-driver/mysql"
    _ "github.com/newrelic/go-agent/v3/integrations/nrmysql"
)

func main() {
    // open "nrmysql" in place of "mysql"
    db, err := sql.Open("nrmysql", "user@unix(/path/to/socket)/dbname")
}

ctx := newrelic.NewContext(context.Background(), txn)
row := db.QueryRowContext(ctx, "SELECT count(*) from tables")

s := newrelic.DatastoreSegment{
    Product: newrelic.DatastoreMySQL,
    Collection: "users",
    Operation: "INSERT",
    ParameterizedQuery: "INSERT INTO users (name, age) VALUES ($1, $2)",
    QueryParameters: map[string]interface{}{
        "name": "Dracula",
        "age": 439,
    },
    Host: "mysql-server-1",
    PortPathOrID: "3306",
    DatabaseName: "my_database",
}
s.StartTime = txn.StartSegmentNow()
// ... make the datastore call
s.End()

s := newrelic.DatastoreSegment{
    StartTime: txn.StartSegmentNow(),
    Product: newrelic.DatastoreMySQL,
    Collection: "users",
    Operation: "INSERT",
    ParameterizedQuery: "INSERT INTO users (name, age) VALUES ($1, $2)",
    QueryParameters: map[string]interface{}{
        "name": "Dracula",
        "age": 439,
    },
    Host: "mysql-server-1",
    PortPathOrID: "3306",
    DatabaseName: "my_database",
}
defer s.End()

Segmentos externos

Você pode fazer chamadas do aplicativo Instrumento Go para serviços externos, como serviços web, recursos na nuvem e quaisquer outras chamadas de rede. Os segmentos externos aparecem na tabela APMTransactions breakdown e na páginaExternal services no New Relic.

Existem duas maneiras de instrumentar segmentos externos:

func external(txn *newrelic.Transaction, req *http.Request) (*http.Response, error) {
    s := newrelic.StartExternalSegment(txn, req)
    response, err := http.DefaultClient.Do(req)
    s.Response = response
    s.End()
    return response, err
}

client := &http.Client{}
client.Transport = newrelic.NewRoundTripper(client.Transport)

request, _ := http.NewRequest("GET", "http://example.com", nil)
request = newrelic.RequestWithTransactionContext(request, txn)

response, err := client.Do(request)

Segmentos produtores de mensagens

Você pode chamar o aplicativo Instrumento Go que adiciona mensagens a sistemas de filas como RabbitMQ e Kafka. Os segmentos produtores de mensagens aparecem no APM Transactions breakdown no New Relic.

Só existe uma maneira de instrumentalizar os segmentos produtores de mensagens:

s := newrelic.MessageProducerSegment{
    Library:              "RabbitMQ",
    DestinationType:      newrelic.MessageExchange,
    DestinationName:      "myExchange",
    DestinationTemporary: false,
}
s.StartTime = txn.StartSegmentNow()
// ... add message to queue
s.End()

s := newrelic.MessageProducerSegment{
    StartTime:            txn.StartSegmentNow(),
    Library:              "RabbitMQ",
    DestinationType:      newrelic.MessageExchange,
    DestinationName:      "myExchange",
    DestinationTemporary: false,
}
defer s.End()
// ... add message to queue