Installer New Relic for Go

Obtenez des informations détaillées sur les performances de vos applications Go en installant l'agent New Relic Go. Ce guide vous guide à travers une installation complète avec des exemples pour les modèles d'applications Go courants.

Avant de commencer

• Créez un compte New Relic - Si vous n'en avez pas déjà un, créez un compte New Relic. C'est gratuit, pour toujours.

• Vérifier la compatibilité - Assurez-vous d'avoir :

  • Go 1.19 ou supérieur
  • Linux, macOS ou Windows
  • Un framework ou une bibliothèque webpris en charge

• Obtenez votre clé de licence - Vous aurez besoin de votre clé de licencependant l'installation.

Étapes d'installation

$
go get github.com/newrelic/go-agent/v3/newrelic

import "github.com/newrelic/go-agent/v3/newrelic"

func main() {
    app, err := newrelic.NewApplication(
        newrelic.ConfigAppName("My Go Application"),
        newrelic.ConfigLicense(os.Getenv("NEW_RELIC_LICENSE_KEY")),
    )
    if err != nil {
        log.Fatal("Failed to create New Relic application:", err)
    }

    // Wait for the application to connect
    if err := app.WaitForCompletion(5 * time.Second); err != nil {
        log.Println("Warning: New Relic application did not connect:", err)
    }

    // Your application code here
}

// Method 1: Wrap individual handlers
http.HandleFunc(newrelic.WrapHandleFunc(app, "/", indexHandler))
http.HandleFunc(newrelic.WrapHandleFunc(app, "/users", usersHandler))
http.HandleFunc(newrelic.WrapHandleFunc(app, "/api/data", apiHandler))

// Method 2: Wrap your entire mux (recommended for many routes)
mux := http.NewServeMux()
mux.HandleFunc("/", indexHandler)
mux.HandleFunc("/users", usersHandler)
mux.HandleFunc("/api/data", apiHandler)

http.ListenAndServe(":8080", newrelic.WrapListen(app, mux))

func usersHandler(w http.ResponseWriter, r *http.Request) {
    // Get transaction from request context
    txn := newrelic.FromContext(r.Context())

    user, err := getUserFromDatabase(r.URL.Query().Get("id"))
    if err != nil {
        // Report error to New Relic
        txn.NoticeError(err)
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }

    // Add custom attributes
    txn.AddAttribute("user.id", user.ID)
    txn.AddAttribute("user.tier", user.Tier)

    // Return user data
    json.NewEncoder(w).Encode(user)
}

Exemples d'installation

Serveur HTTP simple

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/newrelic/go-agent/v3/newrelic"
)

func main() {
    // Initialize New Relic
    app, err := newrelic.NewApplication(
        newrelic.ConfigAppName("Simple Go Server"),
        newrelic.ConfigLicense(os.Getenv("NEW_RELIC_LICENSE_KEY")),
    )
    if err != nil {
        log.Fatal(err)
    }

    // Simple handler
    http.HandleFunc(newrelic.WrapHandleFunc(app, "/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    }))

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Intégration du framework Gin

package main

import (
    "os"

    "github.com/gin-gonic/gin"
    "github.com/newrelic/go-agent/v3/integrations/nrgin"
    "github.com/newrelic/go-agent/v3/newrelic"
)

func main() {
    // Initialize New Relic
    app, _ := newrelic.NewApplication(
        newrelic.ConfigAppName("Gin Application"),
        newrelic.ConfigLicense(os.Getenv("NEW_RELIC_LICENSE_KEY")),
    )

    // Set up Gin with New Relic middleware
    r := gin.Default()
    r.Use(nrgin.Middleware(app))

    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "Hello, World!"})
    })

    r.Run(":8080")
}

Monitoring des tâches en arrière-plan

func processBackgroundJob(app *newrelic.Application, jobData JobData) {
    // Create a background transaction
    txn := app.StartTransaction("background-job")
    defer txn.End()

    // Add job context
    txn.AddAttribute("job.id", jobData.ID)
    txn.AddAttribute("job.type", jobData.Type)

    // Process job with error handling
    if err := processJob(jobData); err != nil {
        txn.NoticeError(err)
        log.Printf("Job %s failed: %v", jobData.ID, err)
        return
    }

    log.Printf("Job %s completed successfully", jobData.ID)
}

Que se passe-t-il ensuite ?

Après avoir terminé l'installation de base, vous verrez immédiatement :

• Dashboard APM avec les temps de réponse, le débit et les taux d'erreur pour vos points de terminaison HTTP
• Traces de transactions montrant les requêtes Web les plus lentes
• Suivi des erreurs de base pour les erreurs signalées via txn.NoticeError()

Pour débloquer des capacités de monitoring supplémentaires, vous devrez ajouter plus d'instrumentation :

• Monitoring de la base de données - Nécessite l'instrumentation des segments de base de données
• Suivi des services externes - Nécessite une instrumentation de segment externe
• Métriques et événements personnalisés - Nécessite une instrumentation personnalisée

Dépannage

Si vous ne voyez pas de données après l'installation :

1. Vérifiez les logs de votre application pour les messages de connexion New Relic
2. Vérifiez que votre clé de licence est correcte et non expirée
3. Assurez-vous de la connectivité réseau à New Relic (ports 80/443)
4. Consultez le guide de dépannage pour une aide détaillée

config := newrelic.NewConfig("My App", os.Getenv("NEW_RELIC_LICENSE_KEY"))
config.Logger = newrelic.NewDebugLogger(os.Stdout)
app, _ := newrelic.NewApplication(config)

Prochaines étapes

Maintenant que vous avez configuré le monitoring de base, vous pouvez améliorer votre observabilité grâce à la configuration et à l'instrumentation:

• Configuration contrôle le comportement de l'agent globalement dans l'ensemble de votre application
• L'instrumentation ajoute du code de monitoring à des opérations spécifiques que vous souhaitez suivre

Configurer l'agent

Utilisez la configuration de l'agent pour contrôler le comportement global et obtenir :

• Activer le tracing distribué - Suivez les requêtes sur plusieurs services
• Contrôler le logging - Définir les niveaux de débogage et les destinations des logs
• Définir les seuils de performance - Configurer quand les requêtes sont considérées comme "lentes"
• Activer les fonctionnalités de sécurité - Activez le mode haute sécurité

Ajouter l'instrumentation

Utilisez l'instrumentation détaillée pour monitorer des opérations spécifiques et obtenir :

• Monitorer les requêtes de base de données - Suivez les performances SQL et les requêtes lentes
• Suivre les appels d'API externes - Monitorer les appels de service tiers
• Monitorer les tâches en arrière-plan - Suivez les transactions non web
• Créer des métriques personnalisées - Monitorez les KPI spécifiques à l'entreprise

Fonctionnalités et monitoring avancés

• Explorez les fonctionnalités avancées telles que le monitoring du navigateur et les événements personnalisés
• Configurer des alertes pour les indicateurs de performance clés