Instrumenter Go transactions

Monitorez votre New Relic for Go application ou vos microservices en créant des transactions associées à des activités spécifiques du serveur d'applications, telles que des réponses HTTP ou des tâches en arrière-plan. Vous pouvez ensuite visualiser les performances de votre application dans New Relic, y compris la page APM Transactions .

Identifier les transactions Web et non Web

Contrairement à de nombreux autres langages, les applications Go s'exécutent à partir d'un fichier binaire natif compilé. Cela signifie que la configuration de New Relic pour votre application Golang nécessite que vous ajoutiez manuellement des méthodes New Relic à votre code source.

Dans APM, les transactions sont identifiées comme des transactions Web ou des transactions non Web.

• Lorsque vous instrumentez ou encapsulez une transaction qui dispose d'un rédacteur de requête et de réponse HTTP, New Relic la traite comme un réseau de transactions.
• Lorsque vous instrumentez ou encapsulez une transaction qui ne contient pas de données HTTP, New Relic la traite comme une transaction non Web.

Les segments sont les fonctions et les appels qui composent une transaction. Vous pouvez également utiliser New Relic for Go pour ajouter des détails au niveau du segment à vos transactions.

Monitorer une transaction

Pour monitorer une transaction : placez le code suivant immédiatement après le début de la fonction que vous souhaitez monitorer. Par exemple:

txn := app.StartTransaction("transaction_name")
defer txn.End()

Dans cet exemple de code :

• app fait référence à la variable attribuée lors du processus de configuration de New Relic. Pour plus d'informations, consultez les procédures installation de l'agent Go.
• L'instruction defer diffère la fin du segment jusqu'à la fermeture de la fonction.

Pour monitorer une transaction Web, appelez l'API Transaction.SetWebRequest et éventuellement l'API Transaction.SetWebResponse :

txn := app.StartTransaction("transaction_name")
defer txn.End()

// req is a *http.Request, this marks the transaction as a web transaction
txn.SetWebRequestHTTP(req)

// writer is a http.ResponseWriter, use the returned writer in place of the original
writer = txn.SetWebResponse(writer)
writer.WriteHeader(500)

func checkout() {
    // function code here
}

func checkout() {
    txn := app.StartTransaction("checkout_transaction")
    defer txn.End()
    // function code here
}

Monitorer une transaction avec plusieurs goroutines

Pour monitorer une transaction sur plusieurs goroutines, utilisez Transaction.NewGoroutine(). La méthode NewGoroutine renvoie une nouvelle référence à la transaction, qui est requise par chaque goroutine de création de segment. Peu importe que vous appeliez NewGoroutine avant ou après le démarrage de l'autre goroutine.

Toutes les méthodes Transaction peuvent être utilisées dans n'importe quelle référence Transaction . Le Transactionse terminera lorsque End() sera appelé dans n'importe quelle goroutine.

go func(txn *newrelic.Transaction) {
    defer txn.StartSegment("async").End()
    time.Sleep(100 * time.Millisecond)
}(txn.NewGoroutine())

ch := make(chan *newrelic.Transaction)
go func() {
    txn := <-ch
    defer txn.StartSegment("async").End()
    time.Sleep(100 * time.Millisecond)
}()
ch <- txn.NewGoroutine()

Monitorer une transaction en enveloppant un gestionnaire HTTP

Si vous utilisez le package de bibliothèque HTTP standard, vous pouvez créer des transactions en encapsulant requests HTTP, comme alternative à l'instrumentation du code d'une fonction.

Voici un exemple avant/après d'un gestionnaire HTTP en cours d'encapsulation :

Avant:

http.HandleFunc("/users", usersHandler)

Après:

Cela démarre et termine automatiquement une transaction avec le rédacteur de la demande et de la réponse.

http.HandleFunc(newrelic.WrapHandleFunc(app, "/users", usersHandler))

Pour accéder à la transaction dans votre gestionnaire, utilisez l'API newrelic.FromContext . Notez que cela ne fonctionnera que pour les versions Go 1.7 et plus récentes. Par exemple:

func myHandler(w http.ResponseWriter, r *http.Request) {
    txn := newrelic.FromContext(r.Context())
    txn.NoticeError(errors.New("my error message"))
}

Erreurs de monitoring

New Relic for Go capture les erreurs de trois manières différentes :

Afficher les logs de vos données APM et infrastructure

Vous pouvez également rassembler vos données de log et d'application pour rendre le dépannage plus facile et plus rapide. Avec les logs en contexte, vous pouvez voir les messages de log liés à vos erreurs et les tracer directement dans UI de votre application.

1. Depuis la page Errors, cliquez sur une trace pour accéder à la pageError details .
2. Dans la page des détails de l’erreur, cliquez sur See logs.
3. Pour afficher les détails relatifs à un message individuel du log, cliquez directement sur le message.

Vous pouvez également voir les journaux en contexte de vos données infrastructure , telles que le cluster Kubernetes. Pas besoin de passer à une autre UI.

Méthodes de transaction supplémentaires

L'objet Transaction dispose de plusieurs méthodes facultatives qui peuvent être utilisées pour contrôler le comportement des transactions, telles que NoticeError, AddAttribute et Ignore. Pour obtenir une liste des méthodes de transaction, consultez les méthodes de transaction New Relic for Go sur Godoc.