Instale New Relic para Go

Obtenha insights detalhados de desempenho para suas aplicações Go instalando o agente New Relic Go. Este guia orienta você através de uma instalação completa com exemplos para padrões comuns de aplicações Go.

Antes de você começar

• Crie uma conta New Relic - Se você ainda não tiver uma, crie uma conta New Relic. É grátis, para sempre.

• Verifique a compatibilidade - Certifique-se de ter:

  • Go 1.19 ou superior
  • Linux, macOS ou Windows
  • Uma estrutura ou biblioteca da webcompatível

• Obtenha sua chave de licença - Você precisará da sua chave de licençadurante a instalação.

Etapas de instalação

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

Exemplos de instalação

Servidor HTTP simples

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

Integração da estrutura 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")
}

Monitoramento de tarefas em 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)
}

O que acontece em seguida?

Após concluir a instalação básica, você verá imediatamente:

• Dashboard do APM com tempos de resposta, taxa de transferência e taxas de erro para seus endpoints HTTP
• Rastreios de transações mostrando as solicitações da web mais lentas
• Rastreamento básico de erros para erros relatados via txn.NoticeError()

Para desbloquear recursos de monitoramento adicionais, você precisará adicionar mais instrumentação:

• Monitoramento de banco de dados - Requer instrumentação de segmento de banco de dados
• Rastreamento de serviço externo - Requer instrumentação de segmento externo
• Métricas e eventos personalizados - Requer instrumentação personalizada

Resolução de problemas

Se você não vir dados após a instalação:

1. Verifique os logs da sua aplicação para mensagens de conexão do New Relic
2. Verifique se sua chave de licença está correta e não expirou
3. Certifique-se da conectividade de rede com o New Relic (portas 80/443)
4. Consulte o guia de solução de problemas para obter ajuda detalhada

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

Próximos passos

Agora que você configurou o monitoramento básico, pode aprimorar sua observabilidade por meio de configuração e instrumentação:

• Configuração controla como o agente se comporta globalmente em todo o seu aplicativo
• Instrumentação adiciona código de monitoramento a operações específicas que você deseja rastrear

Configurar o agente

Use a configuração do agente para controlar o comportamento global e obter:

• Habilite o rastreamento distribuído - Rastreie solicitações em vários serviços
• Controle o logging - Defina níveis de depuração e destinos de log
• Defina limites de desempenho - Configure quando as consultas são consideradas "lentas"
• Habilite os recursos de segurança - Ative o modo de alta segurança

Adicionar instrumentação

Use instrumentação detalhada para monitorar operações específicas e obter:

• Monitore consultas ao banco de dados - Acompanhe o desempenho do SQL e consultas lentas
• Rastreie chamadas de API externas - Monitore chamadas de serviço de terceiros
• Monitore tarefas em segundo plano - Acompanhe transações não web
• Crie métricas personalizadas - Monitore KPIs específicos do negócio

Recursos e monitoramento avançados

• Explore recursos avançados como monitoramento de navegador e eventos personalizados
• Configure alertas para métricas de desempenho importantes