Go release notes

Go agent release notes

Wednesday, July 1, 2020 - 10:30 Download

3.8.0

Changes

  • When marking a transaction as a web transaction using Transaction.SetWebRequest, it is now possible to include a Host field in the WebRequest struct, which defaults to the empty string.

Bug Fixes

  • The Host header is now being correctly captured and recorded in the request.headers.host attribute, as described here.
  • Previously, the timestamps on Spans and Transactions were being written using different data types, which sometimes caused rounding errors that could cause spans to be offset incorrectly in the UI. This has been fixed.
Thursday, June 18, 2020 - 09:30 Download

3.7.0

Changes

  • When Config.Transport is nil, no longer use the http.DefaultTransport when communicating with the New Relic backend. This addresses an issue with shared transports as described in https://github.com/golang/go/issues/33006.

  • If a timeout occurs when attempting to send data to the New Relic backend, instead of dropping the data, we save it and attempt to send it with the next harvest. Note data retention limits still apply and the agent will still start to drop data when these limits are reached. We attempt to keep the highest priority events and traces.

Tuesday, June 9, 2020 - 14:10 Download

3.6.0

New Features

  • Added support for adding custom attributes directly to spans. These attributes will be visible when looking at spans in the distributed tracing UI.

    Example:

    txn := newrelic.FromContext(r.Context())
    sgmt := txn.StartSegment("segment1")
    defer sgmt.End()
    sgmt.AddAttribute("mySpanString", "hello")
    sgmt.AddAttribute("mySpanInt", 123)
    
  • Custom attributes added to the transaction with txn.AddAttribute are now also added to the root span and will be visible when looking at the span in the distributed tracing UI. These custom attributes can be disabled from all destinations using Config.Attributes.Exclude or disabled from spans specifically using Config.SpanEvents.Attributes.Exclude.

  • Agent attributes added to the transaction are now also added to the root span event and will be visible when looking at the span in the distributed tracing UI. These attributes include the request.uri and the request.method along with all other attributes listed in the attributes section of our godocs. These agent attributes can be disabled from all destinations using Config.Attributes.Exclude or disabled from spans specifically using Config.SpanEvents.Attributes.Exclude.

Bug Fixes

  • Fixed an issue where it was impossible to exclude the attributes error.class and error.message from the root span. This issue has now been fixed. These attributes can now be excluded from all spans using Config.Attributes.Exclude or Config.SpanEvents.Attributes.Exclude.

  • Fixed an issue that caused Go's data race warnings to trigger in certain situations when using the newrelic.NewRoundTripper. There were no reports of actual data corruption, but now the warnings should be resolved. Thank you to @blixt for bringing this to our attention!

Wednesday, May 20, 2020 - 15:15 Download

3.5.0

New Features

  • Added support for Infinite Tracing on New Relic Edge.

    Infinite Tracing observes 100% of your distributed traces and provides visualizations for the most actionable data so you have the examples of errors and long-running traces so you can better diagnose and troubleshoot your systems.

    You configure your agent to send traces to a trace observer in New Relic Edge. You view your distributed traces through the New Relic’s UI. There is no need to install a collector on your network.

    Infinite Tracing is currently available on a sign-up basis. If you would like to participate, please contact your sales representative.

Changes

  • nrgin.Middleware uses Context.FullPath() for transaction names when using Gin version 1.5.0 or greater. Gin transactions were formerly named after the Context.HandlerName(), which uses reflection. This change improves transaction naming and reduces overhead. Please note that because your transaction names will change, you may have to update any related dashboards and alerts to match the new name. If you wish to continue using Context.HandlerName() for your transaction names, use nrgin.MiddlewareHandlerTxnNames instead.

    // Transactions previously named
    "GET main.handleGetUsers"
    // will be change to something like this match the full path
    "GET /user/:id"
    

    Note: As part of agent release v3.4.0, a v2.0.0 tag was added to the nrgin package. When using go modules however, it was impossible to install this latest version of nrgin. The v2.0.0 tag has been removed and replaced with v1.1.0.

Monday, March 23, 2020 - 12:51 Download

3.4.0

New Features

  • Attribute http.statusCode has been added to external span events representing the status code on an http response. This attribute will be included when added to an ExternalSegment in one of these three ways:

    1. Using NewRoundTripper with your http.Client
    2. Including the http.Response as a field on your ExternalSegment
    3. Using the new ExternalSegment.SetStatusCode API to set the status code directly

    To exclude the http.statusCode attribute from span events, update your agent configuration like so, where cfg is your newrelic.Config object.

    cfg.SpanEvents.Attributes.Exclude = append(cfg.SpanEvents.Attributes.Exclude, newrelic.SpanAttributeHTTPStatusCode)
    
  • Error attributes error.class and error.message are now included on the span event in which the error was noticed, or on the root span if an error occurs in a transaction with no segments (no chid spans). Only the most recent error information is added to the attributes; prior errors on the same span are overwritten.

    To exclude the error.class and/or error.message attributes from span events, update your agent configuration like so, where cfg is your newrelic.Config object.

    cfg.SpanEvents.Attributes.Exclude = append(cfg.SpanEvents.Attributes.Exclude, newrelic.newrelic.SpanAttributeErrorClass, newrelic.SpanAttributeErrorMessage)
    

Changes

  • Use Context.FullPath() for transaction names when using Gin version 1.5.0 or greater. Gin transactions were formerly named after the Context.HandlerName(), which uses reflection. This change improves transaction naming and reduces overhead. Please note that because your transaction names will change, you may have to update any related dashboards and alerts to match the new name.

    // Transactions previously named
    "GET main.handleGetUsers"
    // will be change to something like this match the full path
    "GET /user/:id"
    
Tuesday, February 11, 2020 - 14:21 Download

3.3.0

New Features

Changes

  • When using newrelic.StartExternalSegment or newrelic.NewRoundTripper, if existing cross application tracing or distributed tracing headers are present on the request, they will be replaced instead of added.

  • The FromContext API which allows you to pull a Transaction from a context.Context will no longer panic if the provided context is nil. In this case, a nil is returned.

Known Issues and Workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream Go New Relic agents to this agent release.

Monday, January 27, 2020 - 11:13 Download

3.2.0

New Features

Changes

  • Updated Gorilla instrumentation to include request time spent in middlewares. Added new nrgorilla.Middleware and deprecated nrgorilla.InstrumentRoutes. Register the new middleware as your first middleware using Router.Use. See the godocs examples for more details.

    r := mux.NewRouter()
    // Always register the nrgorilla.Middleware first.
    r.Use(nrgorilla.Middleware(app))
    
    // All handlers and custom middlewares will be instrumented.  The
    // transaction will be available in the Request's context.
    r.Use(MyCustomMiddleware)
    r.Handle("/", makeHandler("index"))
    
    // The NotFoundHandler and MethodNotAllowedHandler must be instrumented
    // separately using newrelic.WrapHandle.  The second argument to
    // newrelic.WrapHandle is used as the transaction name; the string returned
    // from newrelic.WrapHandle should be ignored.
    _, r.NotFoundHandler = newrelic.WrapHandle(app, "NotFoundHandler", makeHandler("not found"))
    _, r.MethodNotAllowedHandler = newrelic.WrapHandle(app, "MethodNotAllowedHandler", makeHandler("method not allowed"))
    
    http.ListenAndServe(":8000", r)
    

Known Issues and Workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream Go New Relic agents to this agent release.

Wednesday, January 15, 2020 - 14:30 Download

New Features

  • Support for W3C Trace Context, with easy upgrade from New Relic trace context.

    Distributed Tracing now supports W3C Trace Context headers for HTTP and gRPC protocols when distributed tracing is enabled. Our implementation can accept and emit both W3C trace header format and New Relic trace header format. This simplifies agent upgrades, allowing trace context to be propagated between services with older and newer releases of New Relic agents. W3C trace header format will always be accepted and emitted. New Relic trace header format will be accepted, and you can optionally disable emission of the New Relic trace header format.

    When distributed tracing is enabled with Config.DistributedTracer.Enabled = true, the Go agent will now accept W3C's traceparent and tracestate headers when calling Transaction.AcceptDistributedTraceHeaders. When calling Transaction.InsertDistributedTraceHeaders, the Go agent will include the W3C headers along with the New Relic distributed tracing header, unless the New Relic trace header format is disabled using Config.DistributedTracer.ExcludeNewRelicHeader = true.

    Also, see Knowns Issues and Workarounds.

  • Added support for elastic/go-elasticsearch in the new v3/integrations/nrelasticsearch-v7 package.

Known Issues and Workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream Go New Relic agents to this agent release.

Tuesday, December 17, 2019 - 11:09 Download

3.0.0

We are pleased to announce the release of Go Agent v3.0.0! This is a major release that includes some breaking changes that will simplify your future use of the Go Agent.

Please pay close attention to the list of Changes.

Changes

  • A full list of changes and a step by step checklist on how to upgrade can be found in the v3 Migration Guide.

New Features

  • Support for Go Modules. Our Go agent integration packages support frameworks and libraries which are changing over time. With support for Go Modules, we are now able to release instrumentation packages for multiple versions of frameworks and libraries with a single agent release; and support operation of the Go agent in Go Modules environments. This affects naming of our integration packages, as described in the v3 Migration Guide (see under "Changes" above).

  • Detect and set hostnames based on Heroku dyno names. When deploying an application in Heroku, the hostnames collected will now match the dyno name. This serves to greatly improve the usability of the servers list in APM since dyno names are often sporadic or fleeting in nature. The feature is controlled by two new configuration options Config.Heroku.UseDynoNames and Config.Heroku.DynoNamePrefixesToShorten.

Wednesday, December 11, 2019 - 11:11 Download

2.16.3

New Relic's Go agent v3.0 is currently available for review and beta testing. Your use of this pre-release is at your own risk. New Relic disclaims all warranties, express or implied, regarding the beta release.

If you do not manually take steps to use the new v3 folder you will not see any changes in your agent.

This is the third release of the pre-release of Go agent v3.0. It includes changes due to user feedback during the pre-release. The existing agent in "github.com/newrelic/go-agent" is unchanged. The Go agent v3.0 code in the v3 folder has the following changes:

Tuesday, December 10, 2019 - 10:50 Download

2.16.2

New Relic's Go agent v3.0 is currently available for review and beta testing. Your use of this pre-release is at your own risk. New Relic disclaims all warranties, express or implied, regarding the beta release.

If you do not manually take steps to use the new v3 folder you will not see any changes in your agent.

This is the second release of the pre-release of Go agent v3.0. It includes changes due to user feedback during the pre-release. The existing agent in "github.com/newrelic/go-agent" is unchanged. The Go agent v3.0 code in the v3 folder has the following changes:

  • Transaction names created by WrapHandle, WrapHandleFunc, nrecho-v3, nrecho-v4, nrgorilla, and nrgin now include the HTTP method. For example, the following code:

    http.HandleFunc(newrelic.WrapHandleFunc(app, "/users", usersHandler))
    

    now creates a metric called WebTransaction/Go/GET /users instead of WebTransaction/Go/users. As a result of this change, you may need to update your alerts and dashboards.

  • The ConfigFromEnvironment config option is now strict. If one of the environment variables, such as NEW_RELIC_DISTRIBUTED_TRACING_ENABLED, cannot be parsed, then Config.Error will be populated and NewApplication will return an error.

  • ConfigFromEnvironment now processes NEW_RELIC_ATTRIBUTES_EXCLUDE and NEW_RELIC_ATTRIBUTES_INCLUDE.

Monday, December 2, 2019 - 14:15 Download

2.16.1

New Relic's Go agent v3.0 is currently available for review and beta testing. Your use of this pre-release is at your own risk. New Relic disclaims all warranties, express or implied, regarding the beta release.

If you do not manually take steps to use the new v3 folder, as described below, you will not see any changes in your agent.

This 2.16.1 release includes a new v3.0 folder which contains the pre-release of Go agent v3.0; Go agent v3.0 includes breaking changes. We are seeking feedback and hope that you will look this over and test out the changes prior to the official release.

This is not an official 3.0 release, it is just a vehicle to gather feedback on proposed changes. It is not tagged as 3.0 in Github and the 3.0 release is not yet available to update in your Go mod file. In order to test out these changes, you will need to clone this repo in your Go source directory, under [go-src-dir]/src/github.com/newrelic/go-agent. Once you have the source checked out, you will need to follow the steps in the second section of v3/MIGRATION.md.

A list of changes and installation instructions is included in the v3 folder and can be found here

For this pre-release (beta) version of Go agent v3.0, please note:

  • The changes in the v3 folder represent what we expect to release in ~2 weeks as our major 3.0 release. However, as we are soliciting feedback on the changes and there is the possibility of some breaking changes before the official release.
  • This is not an official 3.0 release; it is not tagged as 3.0 in Github and the 3.0 release is not yet available to update in your Go mod file.
  • If you test out these changes and encounter issues, questions, or have feedback that you would like to pass along, please open up an issue here and be sure to include the label 3.0.
    • For normal (non-3.0) issues/questions we request that you report them via our support site or our community forum. Please only report questions related to the 3.0 pre-release directly via GitHub.

New Features

  • V3 will add support for Go Modules. The go.mod files exist in the v3 folder, but they will not be usable until we have fully tagged the 3.0 release officially. Examples of version tags we plan to use for different modules include:
    • v3.0.0
    • v3/integrations/nrecho-v3/v1.0.0
    • v3/integrations/nrecho-v4/v1.0.0

Changes

  • The changes are the ones that we have requested feedback previously in this issue.
  • A full list of changes that are included, along with a checklist for upgrading, is available in v3/MIGRATION.md.
Friday, November 22, 2019 - 15:15 Download

2.16.0

Upcoming

Bug Fixes

  • Fixed an issue in the nrhttprouter integration where the transaction was not being added to the requests context. This resulted in an inability to access the transaction from within an httprouter.Handle function. This issue has now been fixed.
Thursday, October 24, 2019 - 14:00 Download

2.15.0

New Features

  • Added support for monitoring MongoDB queries with the new _integrations/nrmongo package.

  • Added new method Transaction.IsSampled() that returns a boolean that indicates if the transaction is sampled. A sampled transaction records a span event for each segment. Distributed tracing must be enabled for transactions to be sampled. false is returned if the transaction has finished. This sampling flag is needed for B3 trace propagation and future support of W3C Trace Context.

  • Added support for adding B3 Headers to outgoing requests. This is helpful if the service you are calling uses B3 for trace state propagation (for example, it uses Zipkin instrumentation). You can use the new _integrations/nrb3 package's nrb3.NewRoundTripper like this:

    // When defining the client, set the Transport to the NewRoundTripper. This
    // will create ExternalSegments and add B3 headers for each request.
    client := &http.Client{
      Transport: nrb3.NewRoundTripper(nil),
    }
    
    // Distributed Tracing must be enabled for this application.
    // (see https://docs.newrelic.com/docs/understand-dependencies/distributed-tracing/enable-configure/enable-distributed-tracing)
    txn := currentTxn()
    
    req, err := http.NewRequest("GET", "http://example.com", nil)
    if nil != err {
      log.Fatalln(err)
    }
    
    // Be sure to add the transaction to the request context.  This step is
    // required.
    req = newrelic.RequestWithTransactionContext(req, txn)
    resp, err := client.Do(req)
    if nil != err {
      log.Fatalln(err)
    }
    
    defer resp.Body.Close()
    fmt.Println(resp.StatusCode)
    
Tuesday, October 15, 2019 - 14:52 Download

2.14.1

Bug Fixes

  • Removed the hidden "NEW_RELIC_DEBUG_LOGGING" environment variable setting which was broken in release 2.14.0.
Monday, October 14, 2019 - 14:27 Download

2.14.0

New Features

  • Added support for a new segment type, MessageProducerSegment, to be used to track time spent adding messages to message queuing systems like RabbitMQ or Kafka.

    seg := &newrelic.MessageProducerSegment{
      StartTime:       newrelic.StartSegmentNow(txn),
      Library:         "RabbitMQ",
      DestinationType: newrelic.MessageExchange,
      DestinationName: "myExchange",
    }
    // add message to queue here
    seg.End()
    
  • Added new attribute constants for use with message consumer transactions. These attributes can be used to add more detail to a transaction that tracks time spent consuming a message off a message queuing system like RabbitMQ or Kafka. They can be added using txn.AddAttribute.

    // The routing key of the consumed message.
    txn.AddAttribute(newrelic.AttributeMessageRoutingKey, "myRoutingKey")
    // The name of the queue the message was consumed from.
    txn.AddAttribute(newrelic.AttributeMessageQueueName, "myQueueName")
    // The type of exchange used for the consumed message (direct, fanout,
    // topic, or headers).
    txn.AddAttribute(newrelic.AttributeMessageExchangeType, "myExchangeType")
    // The callback queue used in RPC configurations.
    txn.AddAttribute(newrelic.AttributeMessageReplyTo, "myReplyTo")
    // The application-generated identifier used in RPC configurations.
    txn.AddAttribute(newrelic.AttributeMessageCorrelationID, "myCorrelationID")
    

    It is recommended that at most one message is consumed per transaction.

  • Added support for Go 1.13's Error wrapping. Transaction.NoticeError now uses Unwrap recursively to identify the error's cause (the deepest wrapped error) when generating the error's class field. This functionality will help group your errors usefully.

    For example, when using Go 1.13, the following code:

    type socketError struct{}
    
    func (e socketError) Error() string { return "socket error" }
    
    func gamma() error { return socketError{} }
    func beta() error  { return fmt.Errorf("problem in beta: %w", gamma()) }
    func alpha() error { return fmt.Errorf("problem in alpha: %w", beta()) }
    
    func execute(txn newrelic.Transaction) {
    err := alpha()
    txn.NoticeError(err)
    }
    

    captures an error with message "problem in alpha: problem in beta: socket error" and class "main.socketError". Previously, the class was recorded as "*fmt.wrapError".

  • A Stack field has been added to Error, which can be assigned using the new NewStackTrace function. This allows your error stack trace to show where the error happened, rather than the location of the NoticeError call.

    Transaction.NoticeError not only checks for a stack trace (using StackTracer) in the error parameter, but in the error's cause as well. This means that you can create an Error where your error occurred, wrap it multiple times to add information, notice it with NoticeError, and still have a useful stack trace. Take a look!

    func gamma() error {
    return newrelic.Error{
        Message: "something went very wrong",
        Class:   "socketError",
        Stack:   newrelic.NewStackTrace(),
    }
    }
    
    func beta() error  { return fmt.Errorf("problem in beta: %w", gamma()) }
    func alpha() error { return fmt.Errorf("problem in alpha: %w", beta()) }
    
    func execute(txn newrelic.Transaction) {
    err := alpha()
    txn.NoticeError(err)
    }
    

    In this example, the topmost stack trace frame recorded is "gamma", rather than "execute".

  • Added support for configuring a maximum number of transaction events per minute to be sent to New Relic. It can be configured as follows:

    config := newrelic.NewConfig("Application Name", os.Getenv("NEW_RELIC_LICENSE_KEY"))  
    config.TransactionEvents.MaxSamplesStored = 100
    
    • For additional configuration information, see our documentation

Miscellaneous

Monday, September 23, 2019 - 16:15 Download

2.13.0

New Features

Tuesday, September 17, 2019 - 11:00 Download

New Features

  • Added new methods to expose Transaction details:

    • Transaction.GetTraceMetadata() returns a TraceMetadata which contains distributed tracing identifiers.
    • Transaction.GetLinkingMetadata() returns a LinkingMetadata which contains the fields needed to link data to a trace or entity.
  • Added a new plugin for the Logrus logging framework with the new _integrations/logcontext/nrlogrusplugin package. This plugin leverages the new GetTraceMetadata and GetLinkingMetadata above to decorate logs.

    To enable, set your log's formatter to the nrlogrusplugin.ContextFormatter{}

    logger := logrus.New()
    logger.SetFormatter(nrlogrusplugin.ContextFormatter{})
    

    The logger will now look for a newrelic.Transaction inside its context and decorate logs accordingly. Therefore, the Transaction must be added to the context and passed to the logger. For example, this logging call

    logger.Info("Hello New Relic!")
    

    must be transformed to include the context, such as:

    ctx := newrelic.NewContext(context.Background(), txn)
    logger.WithContext(ctx).Info("Hello New Relic!")
    

    For full documentation see the godocs or view the example.

  • Added support for NATS and NATS Streaming monitoring with the new _integrations/nrnats and _integrations/nrstan packages. These packages support instrumentation of publishers and subscribers.

  • Enables ability to migrate to Configurable Security Policies (CSP) on a per agent basis for accounts already using High Security Mode (HSM).

    • Previously, if CSP was configured for an account, New Relic would not allow an agent to connect without the security_policies_token. This led to agents not being able to connect during the period between when CSP was enabled for an account and when each agent is configured with the correct token.
    • With this change, when both HSM and CSP are enabled for an account, an agent (this version or later) can successfully connect with either high_security: true or the appropriate security_policies_token configured - allowing the agent to continue to connect after CSP is configured on the account but before the appropriate security_policies_token is configured for each agent.
Thursday, August 22, 2019 - 14:30 Download

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)
    txn.SetWebRequest(webReq)
    
Wednesday, July 31, 2019 - 15:11 Download

2.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!")
    }
    

Pages