Instrumentar los segmentos Go

Con New Relic for Go, puede monitor los segmentos específicos de una transacción en una aplicación Go para obtener más detalles sobre funciones o bloques de código específicos.

Medir el tiempo para funciones y bloques de código.

Segments son las partes específicas de una transacción en una aplicación. Mediante segmentos instrumentados, puede medir el tiempo que toman funciones y bloques de código, como llamadas externas, llamadas de almacenamiento de datos, agregar mensajes a colas y tareas en segundo plano.

Example: Tiene una transacción asociada con un proceso de pago, que procesa tanto la información de envío como la información de la tarjeta de crédito. Podrías instrumentar tu aplicación para dividir esa transacción en dos partes: un segmento para envío y un segmento para pago.

Segmentos de bloque de código

Una vez que instrumente una transacción, estará listo para instrumentar uno o más segmentos de esa transacción.

Para instrumentar un bloque de código arbitrario como segmento, utilice el siguiente patrón e incluya txn como nombre de variable establecido para la transacción:

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

StartSegment es una ayuda conveniente. Crea un segmento y lo inicia:

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

Segmentos de función

Instrumentar una función como un segmento es esencialmente lo mismo que instrumentar un bloque arbitrario de código como un segmento. La principal diferencia es que, debido a que una función tiene un final discreto, puedes usar la declaración aplazar de Go.

Para instrumentar una función como segmento, agregue el siguiente código al inicio de la función e incluya txn como el nombre de variable establecido para la transacción:

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

Segmentos de nido

Los segmentos se pueden anidar. El segmento que finaliza debe ser el segmento iniciado más recientemente.

A continuación se muestra un ejemplo de un segmento que comienza y termina dentro de otro segmento:

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

Un segmento de valor cero puede finalizarse de forma segura. Por lo tanto, el siguiente código es seguro incluso si el condicional falla:

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

Segmentos de almacenamiento de datos

Puede Instrumentar a la aplicación Go de almacenamiento de datos de llamadas. Los segmentos de almacenamiento de datos aparecen en la tabla APM Transactions breakdown y en la pestaña Databases de la páginaTransactions en New Relic.

Si está utilizando un controlador de base de datos MySQL, PostgreSQL o SQLite, la forma más sencilla de agregar segmentos de almacenamiento de datos es utilizar nuestros paquetes de integración prediseñados. De lo contrario, puede crear manualmente segmentos de almacenamiento de datos para cada llamada a la base de datos.

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

Puede utilizar la aplicación Instrument Go para realizar llamadas a servicios externos, como servicios web, recursos en la nube y cualquier otra llamada de red. Los segmentos externos aparecen en la tabla APMTransactions breakdown y en la páginaExternal services de New Relic.

Hay dos formas 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 de productores de mensajes

Puede utilizar llamadas de la aplicación Go que agregan mensajes a sistemas de cola como RabbitMQ y Kafka. Los segmentos de productores de mensajes aparecen en el APM Transactions breakdown en New Relic.

Sólo hay una forma de instrumentart mensajes a los segmentos de productores:

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