• English日本語한국어
  • ログイン今すぐ開始

Go agent release notesRSS

August 22, 2019
Go agent v2.11.0

New Features

  • Added support for Micro monitoring with the new _integrations/nrmicro package. This package supports instrumentation for servers, clients, publishers, and subscribers.

  • Added support for creating static WebRequest instances manually via the NewStaticWebRequest function. This can be useful when you want to create a web transaction but don't have an http.Request object. Here's an example of creating a static WebRequest and using it to mark a transaction as a web transaction:

    hdrs := http.Headers{}
    u, _ := url.Parse("http://example.com")
    webReq := newrelic.NewStaticWebRequest(hdrs, u, "GET", newrelic.TransportHTTP)
    txn := app.StartTransaction("My-Transaction", nil, nil)

July 31, 2019
Go agent v2.10.0


New Features

  • Added support for custom events when using nrlambda. Example Lambda handler which creates custom event:

    func handler(ctx context.Context) {
    if txn := newrelic.FromContext(ctx); nil != txn {
    txn.Application().RecordCustomEvent("myEvent", map[string]interface{}{
    "zip": "zap",
    fmt.Println("hello world!")

July 10, 2019
Go agent v2.9.0


New Features

  • Added support for gRPC monitoring with the new _integrations/nrgrpc package. This package supports instrumentation for servers and clients.

  • Added new ExternalSegment fields Host, Procedure, and Library. These optional fields are automatically populated from the segment's URL or Request if unset. Use them if you don't have access to a request or URL but still want useful external metrics, transaction segment attributes, and span attributes.

    • Host is used for external metrics, transaction trace segment names, and span event names. The host of segment's Request or URL is the default.
    • Procedure is used for transaction breakdown metrics. If set, it should be set to the remote procedure being called. The HTTP method of the segment's Request is the default.
    • Library is used for external metrics and the "component" span attribute. If set, it should be set to the framework making the call. "http" is the default.

    With the addition of these new fields, external transaction breakdown metrics are changed: External/myhost.com/all will now report as External/myhost.com/http/GET (provided the HTTP method is GET).

  • HTTP Response codes below 100, except 0 and 5, are now recorded as errors. This is to support gRPC status codes. If you start seeing new status code errors that you would like to ignore, add them to Config.ErrorCollector.IgnoreStatusCodes or your server side configuration settings.

  • Improve logrus support by introducing nrlogrus.Transform, a function which allows you to turn a logrus.Logger instance into a newrelic.Logger. Example use:

    l := logrus.New()
    cfg := newrelic.NewConfig("Your Application Name", "__YOUR_NEW_RELIC_LICENSE_KEY__")
    cfg.Logger = nrlogrus.Transform(l)

    As a result of this change, the nrlogrus package requires logrus version v1.1.0 and above.

June 18, 2019
Go agent v2.8.1


Bug Fixes

  • Removed nrmysql.NewConnector since go-sql-driver/mysql has not yet released mysql.NewConnector.

June 11, 2019
Go agent v2.8


New Features

  • Support for Real Time Streaming

    • Event data is now sent to New Relic every five seconds, instead of every minute. As a result, transaction, error, and custom events will now be available in New Relic dashboards in near real time. For more information on how to view your events with a five-second refresh, see the real time streaming documentation.
    • Note that the overall limits on how many events can be sent per minute have not changed. Also, span events, metrics, and trace data is unaffected, and will still be sent every minute.
  • Introduce support for databases using database/sql. This new functionality allows you to instrument MySQL, PostgreSQL, and SQLite calls without manually creating DatastoreSegments.

Database Library Supported

Integration Package







Using these database integration packages is easy! First replace the driver with our integration version:

import (
// import our integration package
_ "github.com/newrelic/go-agent/_integrations/nrmysql"
func main() {
// open "nrmysql" in place of "mysql"
db, err := sql.Open("nrmysql", "user@unix(/path/to/socket)/dbname")

Second, use the ExecContext, QueryContext, and QueryRowContext methods of sql.DB, sql.Conn, sql.Tx, and sql.Stmt and provide a transaction-containing context. Calls to Exec, Query, and QueryRow do not get instrumented.

ctx := newrelic.NewContext(context.Background(), txn)
row := db.QueryRowContext(ctx, "SELECT count(*) from tables")

If you are using a database/sql database not listed above, you can write your own instrumentation for it using InstrumentSQLConnector, InstrumentSQLDriver, and SQLDriverSegmentBuilder. The integration packages act as examples of how to do this.

For more information, see the Go agent documentation on instrumenting datastore segments.

Bug Fixes

March 26, 2019
Go agent v2.7


New Features

  • Added support for server side configuration. Server side configuration allows you to set the following configuration settings in the New Relic APM UI:

    • Config.TransactionTracer.Enabled
    • Config.ErrorCollector.Enabled
    • Config.CrossApplicationTracer.Enabled
    • Config.TransactionTracer.Threshold
    • Config.TransactionTracer.StackTraceThreshold
    • Config.ErrorCollector.IgnoreStatusCodes

    For more information see the server side configuration documentation.

  • Added support for AWS Lambda functions in the new nrlambda package. Please email lambda_preview@newrelic.com if you are interested in learning more or previewing New Relic Lambda monitoring. This instrumentation package requires aws-lambda-go version v1.9.0 or higher.

March 12, 2019
Go agent v2.6


New Features

  • Added support for async: the ability to instrument multiple concurrent goroutines, or goroutines that access or manipulate the same Transaction.

    The new Transaction.NewGoroutine() Transaction method allows transactions to create segments in multiple goroutines!

    NewGoroutine returns a new reference to the Transaction. This must be called any time you are passing the Transaction to another goroutine which makes segments. Each segment-creating goroutine must have its own Transaction reference. It does not matter if you call this before or after the other goroutine has started.

    All Transaction methods can be used in any Transaction reference. The Transaction will end when End() is called in any goroutine.

    Example passing a new Transaction reference directly to another goroutine:

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

    Example passing a new Transaction reference on a channel to another goroutine:

    ch := make(chan newrelic.Transaction)
    go func() {
    txn := <-ch
    defer newrelic.StartSegment(txn, "async").End()
    time.Sleep(100 * time.Millisecond)
    ch <- txn.NewGoroutine()
  • Added integration support for aws-sdk-go and aws-sdk-go-v2.

    When using these SDKs, a segment will be created for each out going request. For DynamoDB calls, these will be Datastore segments and for all others they will be External segments.

    • v1 Documentation
    • v2 Documentation
    • Added span event and transaction trace segment attribute configuration. You may control which attributes are captured in span events and transaction trace segments using the Config.SpanEvents.Attributes and Config.TransactionTracer.Segments.Attributes settings. For example, if you want to disable the collection of "db.statement" in your span events, modify your config like this:
    cfg.SpanEvents.Attributes.Exclude = append(cfg.SpanEvents.Attributes.Exclude,

    To disable the collection of all attributes from your transaction trace segments, modify your config like this:

    cfg.TransactionTracer.Segments.Attributes.Enabled = false

Bug Fixes

  • Fixed a bug that would prevent External Segments from being created under certain error conditions related to Cross Application Tracing.


  • Improved linking between Cross Application Transaction Traces in the APM UI. When Config.CrossApplicationTracer.Enabled = true, External segments in the Transaction Traces details will now link to the downstream Transaction Trace if there is one. Additionally, the segment name will now include the name of the downstream application and the name of the downstream transaction.

  • Update attribute names of Datastore and External segments on Transaction Traces to be in line with attribute names on Spans. Specifically:

    • "uri" => "http.url"
    • "query" => "db.statement"
    • "database_name" => "db.instance"
    • "host" => "peer.hostname"
    • "port_path_or_id" + "host" => "peer.address"

February 14, 2019
Go agent v2.5


  • Added support for New Relic Browser using the new BrowserTimingHeader method on the Transaction which returns a BrowserTimingHeader. The New Relic Browser JavaScript code measures page load timing, also known as real user monitoring. The Pro version of this feature measures AJAX requests, single-page applications, JavaScript errors, and much more! Example use:
func browser(w http.ResponseWriter, r *http.Request) {
hdr, err := w.(newrelic.Transaction).BrowserTimingHeader()
if nil != err {
log.Printf("unable to create browser timing header: %v", err)
// BrowserTimingHeader() will always return a header whose methods can
// be safely called.
if js := hdr.WithTags(); js != nil {
io.WriteString(w, "browser header page")
  • The Go agent now collects an attribute named request.uri on Transaction Traces, Transaction Events, Error Traces, and Error Events. request.uri will never contain user, password, query parameters, or fragment. To prevent the request's URL from being collected in any data, modify your Config like this:
cfg.Attributes.Exclude = append(cfg.Attributes.Exclude, newrelic.AttributeRequestURI)

January 31, 2019
Go agent v2.4

2.4.0 Notes

  • Introduced Transaction.Application method which returns the Application that started the Transaction. This method is useful since it may prevent having to pass the Application to code that already has access to the Transaction. Example use:
txn.Application().RecordCustomEvent("customerOrder", map[string]interface{}{
"numItems": 2,
"totalPrice": 13.75,
  • The Transaction.AddAttribute method no longer accepts nil values since our backend ignores them.

January 24, 2019
Go agent v2.3

2.3.0 Notes

  • Added support for Echo in the new nrecho package.

  • Introduced Transaction.SetWebResponse(http.ResponseWriter) method which sets the transaction's response writer. After calling this method, the Transaction may be used in place of the http.ResponseWriter to intercept the response code. This method is useful when the http.ResponseWriter is not available at the beginning of the transaction (if so, it can be given as a parameter to Application.StartTransaction). This method will return a reference to the transaction which implements the combination of http.CloseNotifier, http.Flusher, http.Hijacker, and io.ReaderFrom implemented by the ResponseWriter. Example:

func setResponseDemo(txn newrelic.Transaction) {
recorder := httptest.NewRecorder()
txn = txn.SetWebResponse(recorder)
fmt.Println("response code recorded:", recorder.Code)
  • The Transaction's http.ResponseWriter methods may now be called safely if a http.ResponseWriter has not been set. This allows you to add a response code to the transaction without using a http.ResponseWriter. Example:
func transactionWithResponseCode(app newrelic.Application) {
txn := app.StartTransaction("hasResponseCode", nil, nil)
defer txn.End()
txn.WriteHeader(200) // Safe!
  • The agent will now collect environment variables prefixed by NEW_RELIC_METADATA_ and KUBERNETES_SERVICE_HOST. These will be added to Transaction events to provide context between your Kubernetes cluster and your services. For details on the benefits (currently in beta) see this blog post
  • The agent now collects the fully qualified domain name of the host and local IP addresses for improved linking with our Infrastructure product.

Copyright © 2024 New Relic Inc.

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.