Known limitations for Go support

Before you start using Go application monitoring, make sure that you are aware of the known limitations.

Support limited to official, stable Go releases

Go support is limited to official, stable Go releases compiled with the Golang toolchain.

OneAgent doesn't support binaries compiled using

Application binaries must be dynamically linked

OneAgent fully automatic injection requires dynamically linked application binaries. Dynamic linking is automatically applied when the application uses certain standard runtime library packages, for example, net/http.

In all other cases, you can enforce dynamic linking through the -ldflags="-linkmode=external" command line option. Note that disabling cgo, for example, using CGO_ENABLED=0, is not supported, and OneAgent will reject the resulting application binary.

package main
import "fmt"

func main() {
    fmt.Print("Enter text: ")
    var input string
    fmt.Scanln(&input)
    fmt.Print(input)
}

go build GoMinimal.go
file GoMinimal
GoMinimal: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

go build -ldflags="-linkmode=external" GoMinimal.go
file GoMinimal
GoMinimal: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32

Applications built with -linkshared option aren't supported

Go supports dynamic linking of the Go standard library. This build mode is rarely used, and OneAgent won't inject into applications built this way.

go install -buildmode=shared -linkshared std
go build -linkshared GoMinimal.go

Applications built with -buildmode=pie option and CGO disabled aren't supported

Building the application with -buildmode=pie and CGO_ENABLED=0 results in a dynamically linked application binary but without libc system library dependency, libc is required by OneAgent.

package main
import "fmt"

func main() {
    fmt.Print("Enter text: ")
    var input string
    fmt.Scanln(&input)
    fmt.Print(input)
}

CGO_ENABLED=0 go build -buildmode=pie main.go

Applications that load Go plugins aren't supported

A Go plugin is a package compiled using the -buildmode=plugin build flag to produce a shared object file. This build mode is rarely used, and OneAgent will disable deep monitoring when an application actually loads a Go plugin.

Vendored third-party packages aren't supported

Go vendoring is used to include local copies of external dependencies in the project repository. This approach was used to pin versions of third-party packages before Go module support was added.

OneAgent will not monitor vendored packages. For example, gRPC services are supported only if you use Go modules or if you import go-grpc directly without using a dependency management system.

Possible limitations without a symbol table

By default, Go generates application binaries that contain a symbol table.

Currently there are no known limitations for stripped binaries in Dynatrace. However, we can't guarantee that all current features will continue to work in future Go versions or that all features added later will be supported in stripped binaries.

We therefore recommend that you build Go binaries that contain a symbol table and avoid the use of command line parameters or external tools that might suppress it.

In Dynatrace, monitoring of stripped binaries is enabled by default. However, you can disable the feature for the tenant by turning off Go stripped binaries on the OneAgent features settings page.

Applications built with race detector enabled aren't supported

An application built with -race flag contains a built-in data race detector. This build mode is mostly used in a development environment and OneAgent won't inject into applications built this way.

Creation stack profiling of OS threads is disabled

OneAgent does not support the predefined threadcreate profile. Thread creation profiling results of Go applications monitored by OneAgent will contain empty stack traces only.

Support for static monitoring

OneAgent version 1.203+

After you enable Go static monitoring, automatic injection for statically linked Go binaries is supported by OneAgent if

Limitations

Side effects

The file proc/<pId>/exe refers to an executable named oneagentdynamizer instead of the Go application binary, it is contained in the proc pseudo-filesystem that provides an interface to kernel data structures of running processes. This may cause system tools like ps or top to display oneagentdynamizer instead of the Go binary name in their output.

Support for musl libc

The musl libc library is a drop-in replacement for the glibc library. Dynatrace supports musl-based Go applications, such as those built on Alpine Linux.

There is one additional requirement for building a dynamically linked application binary. You should use the Go toolchain for alpine (golang:<version>-alpine) and add -ldflags="-linkmode external" (or add -linkmode external to an existing -ldflags) to the build command line to enforce usage of the system linker. This is not required for statically linked Go applications watched by Go static monitoring.

package main
import "fmt"

func main() {
    fmt.Print("Enter text: ")
    var input string
    fmt.Scanln(&input)
    fmt.Print(input)
}

# --- Stage 1:
# Use Golang toolchain for alpine to build the application.
FROM golang:1.13.5-alpine as builder
RUN apk update && apk add gcc libc-dev

# Copy local code, for example, GoMinimal.go, to the container image.
COPY ./GoMinimal.go ./GoMinimal.go

# Build dynamically linked Go binary.
RUN go build -ldflags="-linkmode=external" GoMinimal.go
# or add '-linkmode=external' to existing ldflags:
# e.g.: go build -ldflags="-linkmode=external <other linker flags>" GoMinimal.go

# --- Stage 2:
# Use a Docker multi-stage build to create a lean production image.
FROM alpine:3.11
# Install ca-certificates and libc6-compat for Go programs to work properly.
RUN apk add --no-cache ca-certificates libc6-compat

# Copy the binary to the production image from the builder stage.
COPY --from=builder /go/GoMinimal /GoMinimal

# Run the application on container startup.
CMD ["/GoMinimal"]

docker build -t gominimal-alpine .
docker run --interactive gominimal-alpine