How to integrate with Negroni? about go-agent

[ianomad]

@antonholmquist
Roughly it would look something like this:
https://gist.github.com/ianomad/4bb66617316836131e2f62e3d0abfdbd

I didn't try to run it locally, just in case.

[antonholmquist]

Great! Seems to work :) One thing, it should be fmt.Sprintf instead of fmt.Sprint on line 21. And by the way, the path doesn't include the query params, wouldn't you recommend adding this to the transaction name?

Also, maybe this this be added to the docs somewhere?

[willnewrelic]

Hi antonholmquist

Supposing you are using negroni just like the getting started example here:
(https://github.com/urfave/negroni#getting-started) you have a couple options:

• You can add instrumentation to select routes when registering them with your
  mux.

func main() {
    config := newrelic.NewConfig("negroni example", "__LICENSE_KEY__")
    config.Logger = newrelic.NewDebugLogger(os.Stdout)
    app, err := newrelic.NewApplication(config)
    if nil != err {
        fmt.Println(err)
        os.Exit(1)
    }

    mux := http.NewServeMux()
    mux.HandleFunc(newrelic.WrapHandleFunc(app, "/", func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, "Welcome to the home page!")
    }))

    n := negroni.Classic() // Includes some default middlewares
    n.UseHandler(mux)

    http.ListenAndServe(":3000", n)
}

• You can replace the mux with another mux that adds the instrumentation:

type wrapMux struct {
    app      newrelic.Application
    original *http.ServeMux
}

func (mux wrapMux) Handle(p string, h http.Handler) {
    mux.original.Handle(newrelic.WrapHandle(mux.app, p, h))
}

func (mux wrapMux) HandleFunc(p string, h func(http.ResponseWriter, *http.Request)) {
    mux.original.HandleFunc(newrelic.WrapHandleFunc(mux.app, p, h))
}

func (mux wrapMux) Handler(r *http.Request) (h http.Handler, p string) {
    return mux.original.Handler(r)
}

func (mux wrapMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    mux.original.ServeHTTP(w, r)
}

func main() {
    config := newrelic.NewConfig("negroni example", "__LICENSE_KEY__")
    config.Logger = newrelic.NewDebugLogger(os.Stdout)
    app, err := newrelic.NewApplication(config)
    if nil != err {
        fmt.Println(err)
        os.Exit(1)
    }

    mux := wrapMux{
        original: http.NewServeMux(),
        app:      app,
    }
    mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, "Welcome to the home page!")
    })

    n := negroni.Classic() // Includes some default middlewares
    n.UseHandler(mux)

    http.ListenAndServe(":3000", n)
}

• You can introduce a negroni middleware to add the instrumentation, as
  demonstrated by the example from @ianomad. Unfortunately, this approach
  necessitates naming the transaction using properties of the request (or
  having a single transaction name). As @mikegleasonjr said, using the path as
  the transaction name has the downside that it could lead to an explosion of
  transaction names. Though is not a concern if the app is a backend service
  (and the consumers will definitely not make requests with spurious paths), we
  generally don't recommend it. For the same reason, using the query params
  in the transaction name is not recommended.

I hope this helps.