Instrumenter les segments Go

Avec New Relic for Go, vous pouvez monitorer les segments spécifiques d'une transaction dans une application Go pour obtenir plus de détails sur des fonctions ou des blocs de code spécifiques.

Mesurer le temps pour les fonctions et les blocs de code

Segments sont les parties spécifiques d'une transaction dans une application. Grâce aux segments instrumentés, vous pouvez mesurer le temps pris par les fonctions et les blocs de code, tels que les appels externes, les appels datastore, l'ajout de messages aux files d'attente et les tâches en arrière-plan.

Example: Vous avez une transaction associée à un processus de paiement, qui traite à la fois les informations d'expédition et les informations de carte de crédit. Vous pouvez instrumenter votre application pour diviser cette transaction en deux parties : un segment pour l'expédition et un segment pour le paiement.

Segments de blocs de code

Une fois que vous avez instrumenté une transaction, vous êtes prêt à instrumenter un ou plusieurs segments de cette transaction.

Pour instrumenter un bloc de code arbitraire en tant que segment, utilisez le modèle suivant et incluez txn comme nom de variable défini pour la transaction :

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

StartSegment est une aide pratique. Il crée un segment et le démarre :

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

Segments de fonction

instrumenter une fonction en tant que segment est essentiellement la même chose qu'instrumenter un bloc de code arbitraire en tant que segment. La principale différence est que, comme une fonction a une fin discrète, vous pouvez utiliser l'instruction defer de Go.

Pour instrumenter une fonction en tant que segment, ajoutez le code suivant au début de la fonction et incluez txn comme nom de variable défini pour la transaction :

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

Segments de nidification

Les segments peuvent être imbriqués. Le segment terminé doit être le segment le plus récemment démarré.

Voici un exemple d'un segment commençant et se terminant à l'intérieur d'un autre segment :

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

Un segment de valeur zéro peut être terminé en toute sécurité. Par conséquent, le code suivant est sûr même si la condition échoue :

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

segments de la banque de données

Vous pouvez instrumenter les application datastore appels Go. les segments de banque de données apparaissent dans la table APM Transactions breakdown et dans l'onglet Databases de la pageTransactions dans New Relic.

Si vous utilisez un pilote de base de données MySQL, PostgreSQL ou SQLite, le moyen le plus simple d'ajouter des segments de banque de données est d'utiliser notre package d'intégration prédéfini. Sinon, vous pouvez créer manuellement des segments de banque de données pour chaque appel de base de données.

Il existe un package d'intégration pour chaque pilote de base de données que nous prenons en charge :

base de données bibliothèque prise en charge	packaged'intégration
go-sql-driver/mysql	v3/intégration/nrmysql
lib/pq	v3/intégration/nrpq
mattn/go-sqlite3	v3/intégration/nrsqlite3

Pour utiliser l'une de ces intégrations, remplacez d'abord le pilote par notre version d'intégration :

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")
}

Deuxièmement, utilisez les méthodes ExecContext, QueryContext et QueryRowContext de sql.DB, sql.Conn, sql.Tx et sql.Stmt et fournissez un contexte contenant la transaction. Les appels à Exec, Query et QueryRow ne sont pas instrumentés.

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

Si vous utilisez une base de données/base de données SQL non répertoriée ci-dessus, vous pouvez écrire votre propre instrumentation à l'aide de InstrumentConnector, InstrumentDriver et DriverSegmentBuilder. Le package d’intégration sert d’exemple pour montrer comment procéder.

Important

Les packages d'intégration de datastore pour MySQL, PostgreSQL et SQLite ont été ajoutés dans l'agent Go v2.8.0 et nécessitent Go v1.10 ou supérieur.

Tout comme les segments de base, les segments datastore commencent lorsque le champ StartTime est renseigné et se terminent lorsque la méthode End est appelée. Pour instrumenter un segment datastore, placez les éléments suivants au début de la fonction que vous souhaitez monitorer :

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

Pour plus d'informations sur :

Affectation des Collection Operation``DatabaseNamevaleurs,, et autres paramètres : consultez la New Relic datastore documentation du segment sur GoDoc.
Valeurs disponibles pour Product: consultez la documentation New Relic sur GitHub.

Lorsque vous instrumentez un appel datastore qui couvre un appel de fonction entier, vous pouvez utiliser l'instruction defer pour simplifier instrumentation:

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

Segments externes

Vous pouvez instrumenter les appels application Go vers des services externes, tels que des services Web, des ressources dans le cloud et tout autre appel réseau. Les segments externes apparaissent dans la table Transactions breakdown et la pageExternal services dans New Relic.

Il existe deux manières d’ instrumenter des segments externes :

Recommandation : utilisez l'assistant StartExternalSegment, car New Relic l'utilise pour trace l'activité entre vos applications à l'aide du traçage distribué.

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
}

NewRoundTripper renvoie un http.RoundTripper, qui vous permet d' instrument des appels externes sans appeler StartExternalSegment en modifiant le champ Transport de votre http.Client. Le RoundTripper renvoyé recherchera un Transaction dans le contexte de la requête en utilisant FromContext.

Voici un exemple d'instrumentation NewRoundTripper :

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)

Segments producteurs de messages

Vous pouvez instrumenter les appels application Go qui ajoutent des messages au système de mise en file d'attente comme RabbitMQ et Kafka. Les segments du producteur de messages apparaissent dans l'APM Transactions breakdown dans New Relic.

Il n'existe qu'une seule façon d'instrumenter les segments producteurs de messages :

Tout comme les segments de base, les segments producteurs de messages commencent lorsque le champ StartTime est renseigné et se terminent lorsque la méthode End est appelée. Pour instrumenter un segment producteur de messages, placez les éléments suivants au début de la fonction que vous souhaitez monitorer :

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

Pour plus d'informations sur l'attribution des champs Library, DestinationType, DestinationName ou DestinationTemporary, consultez la documentation du segment du producteur de messages New Relic sur GoDoc.

Lorsque vous instrumentez un appel de producteur de message qui s'étend sur un appel de fonction entier, vous pouvez utiliser l'instruction defer pour simplifier instrumentation:

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

Important

Des segments de producteurs de messages ont été ajoutés dans la version 2.14.0 d'Agent Go.

Cette traduction automatique est fournie pour votre commodité.

Mesurer le temps pour les fonctions et les blocs de code

Segments de blocs de code

Segments de fonction

Segments de nidification

segments de la banque de données

Utiliser le package d'instrumentation

Important

Utiliser `DatastoreSegment`

Segments externes

Utiliser `StartExternalSegment()`

Utiliser `NewRoundTripper()`

Segments producteurs de messages

Utiliser `MessageProducerSegment`

Important

Cette traduction automatique est fournie pour votre commodité.

Instrumenter les segments Go

Mesurer le temps pour les fonctions et les blocs de code .css-21sua1{background:none;border:none;width:0;padding:0;}

Segments de blocs de code

Segments de fonction

Segments de nidification

segments de la banque de données

Utiliser DatastoreSegment

Segments externes

Utiliser StartExternalSegment()

Utiliser NewRoundTripper()

Segments producteurs de messages

Utiliser MessageProducerSegment

Mesurer le temps pour les fonctions et les blocs de code

Utiliser `DatastoreSegment`

Utiliser `StartExternalSegment()`

Utiliser `NewRoundTripper()`

Utiliser `MessageProducerSegment`