Go Agent Release Notes

Latest Version: 0.6.1

2026-06-24

v0.6.1

New Added yaml add rule

Automatically creates new files in the same package at build time without overwriting existing files.
The previous append: true method is replaced by the add rule. Old append: true yaml files are blocked at build time with a guidance message.

New LLM monitoring support

Go LLM SDKs are automatically instrumented without code changes. LLM outbound calls, token usage, and response latency are displayed on the WhaTap dashboard.
Supported SDKs: sashabaranov/go-openai, cloudwego/eino-ext, anthropics/anthropic-sdk-go, openai/openai-go.
Enable by adding llm_enabled=true to whatap.conf.
If importing the LLM adapter directly, run go get github.com/whatap/go-api/instrumentation/llm@latest.

Feature Kafka(sarama) outbound call collection

Kafka Producer calls now appear in outbound call statistics on the WhaTap dashboard.

Changed Build command cleanup

Removed deprecated init / inject / generate / uninit subcommands and -wrap / -no-output options.

Changed Disabled fmt log instrumentation by default

fmt.Print* instrumentation is now disabled by default. Enable with enabled_packages: [fmt].
May cause overhead in high-frequency logging applications.

Fixed Improved auto instrumentation stability

Fixed startup errors for apps with existing gRPC interceptors (now works alongside existing interceptors).
Fixed build errors in certain nested code patterns.
Fixed duplicate transaction creation in some scenarios.

Fixed Reduced log instrumentation overhead

Removed unnecessary overhead that occurred even when log collection was disabled.

2026-02-25

v0.5.4

New External module automatic instrumentation

Internal modules fetched via go get can also be automatically instrumented using the -external-module option

whatap-go-inst --external-module=mycompany.com/internal/lib go build ./...

New Added auto-detection patterns for net/http and fasthttp

Automatically detects and wraps http.Server{Handler}, http.Handle(), fasthttp.Server{Handler} struct literal patterns

Feature Added framework Wrap functions

Added 8 Wrap functions including whataphttp.WrapHandler(), whatapfasthttp.WrapHandler(), whataplogrus.WrapLogger()

Changed Changed logrus instrumentation pattern

Changed from SetOutput method to Hook method to avoid conflicts with the app's logrus output configuration

Changed Resolved security vulnerabilities

Upgraded the data relay agent's Go build version to 1.24.13 and removed OTLP-related dependencies to resolve 108 security vulnerabilities

Fixed Improved auto instrumentation stability

Fixed code transformation in anonymous functions (Cobra Command, etc.), detection of framework.New() in struct field initialization, handling of empty main() functions, and gorilla/mux fork compatibility issues

2026-02-05

v0.5.3

Fixed Fixed compilation error when wrapping Aerospike v6 Close() method

Fixed Fixed duplicate declaration error when calling Sarama NewConfig() more than twice in the same function

2026-02-04

v0.5.2

Fixed Fixed issue where tags flag value was being converted to build targets in wrap mode

Fixed Fixed issue where version information was displayed as dev during go install

2026-01-25

v0.5.1

Feature Distributed tracing support for package-level http.Client and client.Do() patterns

Fixed Fixed issue where go-redis v7 was incorrectly detected (only v8/v9 are supported)

2026-01-22

v0.5.0

New Go 1.18 version required

The minimum Go version for the go-api module has been upgraded from 1.17 to 1.18. This is necessary to implement Wrap functions using Go 1.18's Generics feature.

Caution

go-api v0.5.0 cannot be used with Go 1.17 or earlier versions.

New Automatic instrumentation tool whatap-go-inst

Supports Go AST-based source code automatic instrumentation CLI tool. Automatically inserts monitoring code at build time without directly modifying source code.

# Install
go install github.com/whatap/go-api-inst/cmd/whatap-go-inst@latest

# Usage
whatap-go-inst init
go get github.com/whatap/go-api@latest
go mod tidy
whatap-go-inst go build ./...

Supported libraries

Web: Gin, Echo, Fiber, Chi, Gorilla Mux, net/http, FastHTTP
DB: database/sql, sqlx, GORM
Redis: Redigo, go-redis (v8, v9)
NoSQL: MongoDB, Aerospike
Message Queue: Sarama (IBM/Shopify)
RPC: gRPC, Kubernetes client-go
Log: log, logrus, zap

New Active Stack feature

Collect goroutine stacks of running transactions in real-time to analyze bottleneck sections.

active_stack_enabled=true   # default: true
active_stack_second=10      # collection interval (seconds)
active_stack_count=100      # maximum collection count

New Transaction-linked log collection (TraceLogWriter)

Automatically links transaction information of the current goroutine when outputting logs.

import "github.com/whatap/go-api/logsink"

log.SetOutput(logsink.GetTraceLogWriter(os.Stderr))

Automatic transaction context linking based on goroutine ID
Maintains compatibility with existing GetWriterHookStderr()

New Added supported libraries

Library	Package	whatap module
go-redis v9	github.com/redis/go-redis/v9	whatapgoredis
go-redis v8	github.com/go-redis/redis/v8	whatapgoredis
sqlx	github.com/jmoiron/sqlx	whatapsqlx
MongoDB	go.mongodb.org/mongo-driver	whatapmongo
Aerospike	github.com/aerospike/aerospike-client-go	sql.Wrap
fmt.Print	fmt	whatapfmt

Feature Generic Wrap[T] function (Go 1.18 Generics)

Added generic Wrap function using Go 1.18's Generics.

result := trace.Wrap(ctx, "operation", func() int {
    return doSomething()
})

trace.Wrap[T], trace.WrapError[T], trace.WrapVoid
sql.Wrap[T], httpc.Wrap[T], method.Wrap[T]

Feature DB connection tracking (StartOpen)

Monitors database connection points. (SQL_TYPE_DBC)

whatapgorm, whatapredigo, whatapgoredis, whatapsql, whatapsqlx

Feature HTTP client mtrace header support

Automatically adds mtrace header for multi-transaction tracking.

Changed Improved goroutine ID-based transaction tracking

Improved to find TraceContext using goroutine ID even when context is nil. The default value of go.use_goroutine_id_enabled has been changed from false to true, allowing SQL and HTTP transaction linking to work properly even in environments where context is not passed.

Fixed Fixed LineBuffer.Append() bug

Fixed a bug that occurred in the LineBuffer.Append() function during log collection.

Fixed Removed deprecated mongo.NewClient

Changed deprecated mongo.NewClient to mongo.Connect in whatapmongo.

Fixed Fixed URL path "/" blank conversion bug

Fixed an issue where the "/" path was converted to blank due to using filepath.Join.

2025-11-19

v0.4.6

Fixed Fixed environment variable processing bug in agent name pattern

Fixed an issue where the {env.environment_variable_name} pattern in object_name configuration was not working properly.

# Configuration example
object_name={env.SERVER_NAME}-{pid}

# Environment variable: SERVER_NAME=web-server-01
# Result: Agent name web-server-01-12345

Feature Log stdout output

In container environments, logs can now be checked via stdout.

log_stdout_enabled=true  # default: false

Feature Process ID pattern support

Process ID can now be included in agent names. Useful when running multiple processes on the same server.

object_name=myapp-{pid}
# Result: myapp-12345

Feature HTTP status code statistics

Transaction statistics are now collected by HTTP status code.

5-second statistics

Count/time aggregation by HTTP status code
Bucket aggregation by 200/400/500 series status
Detailed aggregation by individual status code

5-minute statistics

Count/time/error aggregation by URL + Status combination
Sent to server every 5 minutes

Configuration options

tx_status_meter_enabled=true      # 5-second statistics (default: true)
stat_txstatus_enabled=true        # 5-minute statistics (default: true)
stat_txstatus_max_count=10000     # Maximum number of items

Feature Kubernetes container ID integration

Container IDs can now be accurately integrated in Kubernetes environments.

How it works

When Go Agent starts, it creates the container ID in a container.conf file
The generated container ID is used to integrate with Kubernetes monitoring

# Add environment variables to Deployment YAML
env:
  # Go Agent executable path
  - name: WHATAP_GO_AGENT_PATH
    value: /usr/whatap/agent/whatap_agent_static

  # Path where container ID will be stored
  - name: WHATAP_CONTAINER_CONF_PATH
    value: /usr/whatap/agent

2025-09-12

v0.4.5

Fixed Fixed transaction collection error

Issue where error message collection caused transactions not to be collected properly has been fixed
Changed default values of problematic options to false
txtext_txname_enabled=false
txtext_error_enabled=false
If using v0.4.4, disabling these options resolves the issue

2025-09-08

v0.4.4

Fixed Fixed duplicate calculation issue when collecting CPU core metering information from multiple containers in Docker environment

Fixed issue where metering information was mixed with other data during transmission
Corrected error where duplicate calculation was not prevented based on Linux UUID

2024-10-16

v0.4.3

Fixed Fixed the error collecting os.Stdout and os.Stderr logs.

It modified the trace.Init function to enable log collection. It changes to run before other log libraries if possible.
The function has been added that allows to use io.Writer that wraps os.Stdout and os.Stderr.

2024-09-06

v0.4.2

Fixed Fixed the compilation error caused by missing library files.

2024-08-28

v0.4.1

New Added the standard output log collection feature.

New Added the option to prioritize environment variables over the agent configuration file (whatap.conf).

Agent settings are applied in the order of whatap.conf and then environment variables.
When the use_env_first option (default value: false) is set, environment variables take precedence over the settings in the whatap.conf file.
whatap.conf
```
use_env_first=true
```
Alternatively, you can set the environment variable as WHATAP_USE_ENV_FIRST=true.

Changed Changed the default values for the following agent options.

The TCP read timeout has been changed from 30 seconds to 120 seconds.
whatap.conf
```
net_so_time=120000
```
The TCP write buffer value has been changed from 8 Mb to 2 Mb.
whatap.conf
```
net_write_buffer_size=2*1024*1024
```

Fixed Fixed the recognition error for the OKIND environment variable.

You can set okind by using the OKIND or WHATAP_OKIND environment variable.

2024-06-19

v0.4.0

New Supported linux aarch64.

Changed Used the security.conf file instead of paramkey.txt

It uses the value of the paramkey key in the previous security.conf file. The default value has been changed to WHATAP instead of a random value. If "WHATAP" is specified, decryption is enabled without entering a key.

Changed Changed the normalization option setting for SQL statements.

Always enable normalization by separating parameters in SQL statements. Always set the trace_sql_normalize_enabled option to true.
If you have already disabled the normalization option (disable normalization), activate the setting to normalize and display parameters separately.
- Set the profile_sql_param_enabled option to true.
- Normalized parameters are separately encrypted and collected.
- You can check the data by decrypting it with paramkey in security.conf.

Changed Changed the monitoring stop feature.

If there is no trace.Init() function call (comment and delete), the monitoring is not started.
enabled option setting (true): It stops collecting data. The agent's internal background modules are maintained.
Set shutdown option (true): It stops all agent features. To restart the application, change the shutdown option to true and then restart the application.

Fixed Fixed the issue where the IP of the server in which the agent has been installed, is collected as 127.0.0.1, and collected it as the local address IP connected to the WhaTap server via TCP.

2024-03-14

v0.3.3

Fixed Deleted the replace syntax in go.mod (deleted the replace syntax in github.com/whatap/golib module).

Fixed Fixed the example source build error (github.com/whatap/go-api-example).

2024-03-06

v0.3.2

Changed Modified to use variables in date format for naming the log monitoring files.

Modified based on the use of Python strftime(). e.g. 20240101: %Y%m%d

Fixed Fixed the gRPC header collection error.

2024-01-24

v0.3.1

Fixed Fixed the bug where only the hash (number) value appears, not the name, after setting the whatap.onode option.

Fixed Fix the bug where the whatap-agent.service file is not recognized in Ubuntu 14.

2024-01-10

v0.3.0

Feature Trace context (W3C) is supported in the multi-transaction tracing.

OpenTelmetry that supports the trace context, and the multi-transaction tracing correlation are supported.

Changed Modified the resource collection for SQL, Method, and HTTP call.

The differences between resources (CPU, memory) at the start of the transaction and the start of each step are collected.

Changed Modified to newly create the configuration file (whatap.conf) if nothing.

Fixed Fixed the error where the cumulative number of outbound calls are collected wrong as the cumulative time in the active transation list.

Fixed Fixed the whatap-agent service (whatap-agent.service) execution error in the Linux environment.

Latest Version: 0.6.1​