Instalar New Relic para Go

Obtenga información detallada sobre el rendimiento de sus aplicaciones Go instalando el agente de New Relic Go. Esta guía le guiará a través de una instalación completa con ejemplos para patrones comunes de aplicaciones Go.

Antes de que empieces

• Cree una cuenta de New Relic - Si aún no tiene una, cree una cuenta de New Relic. Es gratis, para siempre.

• Verifique la compatibilidad - Asegúrese de tener:

  • Go 1.19 o superior
  • Linux, macOS o Windows
  • Un framework web o bibliotecacompatible

• Obtén tu clave de licencia - Necesitarás tu clave de licenciadurante la instalación.

Pasos de instalación

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

Ejemplos de instalación

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

Integración del 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")
}

Monitoreo de trabajos en segundo plano

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

¿Qué pasa después?

Después de completar la instalación básica, verá inmediatamente:

• Dashboard de APM con tiempos de respuesta, rendimiento y tasas de error para tus endpoints HTTP
• Trazas de transacciones que muestran las solicitudes web más lentas
• Seguimiento básico de errores para errores reportados a través de txn.NoticeError()

Para desbloquear capacidades de monitoreo adicionales, deberá agregar más instrumentación:

• Monitoreo de base de datos - Requiere instrumentación de segmento de base de datos
• Seguimiento de servicio externo - Requiere instrumentación de segmento externo
• Métricas y eventos personalizados - Requiere instrumentación personalizada

Resolución de problemas

Si no ve datos después de la instalación:

1. Verifique los logs de su aplicación para ver los mensajes de conexión de New Relic
2. Verifique que su clave de licencia sea correcta y no haya expirado
3. Asegúrese de la conectividad de red a New Relic (puertos 80/443)
4. Revise la guía de solución de problemas para obtener ayuda detallada

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

Próximos pasos

Ahora que tiene la configuración de monitoreo básica, puede mejorar su observabilidad a través de la configuración y la instrumentación:

• La configuración controla cómo se comporta el agente globalmente en toda su aplicación
• La instrumentación agrega código de monitoreo a operaciones específicas que desea rastrear

Configurar el agente

Usa la configuración del agente para controlar el comportamiento global y lograr:

• Habilite el rastreo distribuido - Rastree las solicitudes en múltiples servicios
• Controle el logging - Establezca los niveles de depuración y los destinos de logs
• Establece umbrales de rendimiento - Configura cuándo las consultas se consideran "lentas"
• Habilita las funciones de seguridad - Activa el modo de alta seguridad

Agregue instrumentación

Use instrumentación detallada para monitorear operaciones específicas y lograr:

• Monitoree las consultas de la base de datos - Rastree el rendimiento de SQL y las consultas lentas
• Rastree las llamadas API externas - Monitoree las llamadas a servicios de terceros
• Monitoree los trabajos en segundo plano - Rastree las transacciones que no son web
• Cree métricas personalizadas - Monitoree los KPI específicos del negocio

Funciones y monitoreo avanzados

• Explore funciones avanzadas como el monitoreo del navegador y los eventos personalizados
• Configure alertas para métricas clave de rendimiento