> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/release-notes/runtime-protection-agent/waap-release-notes/2026/agent-release-notes/kong-agent.md).

# Kong Agent

## 2.4.0 - 4<sup>th</sup> November

{% hint style="warning" %}
This release is currently available through manual installation only. Automated installation via standard package channels will be restored in an upcoming update.
{% endhint %}

### Updates

#### Configurable number of concurrent exports

Kong now exposes an `export_max_senders` setting (default 128, range 1 to 1024) that controls how many exports to Traceable can run at once per Kong worker. It applies to exports sent after the response completes, in both sync and async mode; it does not affect the synchronous request-time call to Traceable or AI firewall evaluation calls. These exports count toward Kong's `lua_max_running_timers` limit (default 256 per worker). If multiple plugin instances set different values, the last one to export wins.

#### Exports now use a bounded queue instead of a timer per request

Exports sent after the response, including mid-stream exports for long event-stream responses, now flow through a bounded queue rather than starting a new timer for every request. If the queue fills (10,000 items or 64 MB), new exports are dropped and an error is logged at most once per second, with no separate counter for how many were dropped; client traffic is not affected. This does not change the synchronous request-time call to Traceable or AI firewall evaluation calls.

#### Response body capture is now limited by content type

Response bodies are now captured only for JSON, XML, form-urlencoded, and event-stream responses, in both sync and async mode. Other response types (HTML, plain text, binary, or no Content-Type) are now exported with an empty body; previously all response types were captured. This affects exports only: the AI firewall's response evaluation still receives the full response regardless of type, and request body capture is unchanged.

#### Larger request bodies are now captured, including by the AI firewall

Request bodies larger than the plugin's `client_body_buffer_size` (default 8k) are now captured, in both sync and async mode. Kong reads them from its temp file, up to `max_body_size_bytes` (default 128 KB), and marks them `truncated=true` if they're longer. Previously, these bodies were exported empty. This applies to JSON, XML, and form content types; in async mode it also requires `buffer_request_body` to be on (the default).

To avoid the extra disk read, raise Kong's `nginx_http_client_body_buffer_size` setting (environment variable `KONG_NGINX_HTTP_CLIENT_BODY_BUFFER_SIZE`) to at least `max_body_size_bytes`, for example `128k`. A larger buffer uses more memory per in-flight request. Lowering `max_body_size_bytes` instead reduces how much is read and captured, but it does not remove the disk read for bodies larger than the buffer.

When the AI firewall is enabled in sync mode, it now evaluates these larger bodies too, receiving the first `max_body_size_bytes` with `truncated=true`. Previously, bodies over the buffer size reached policy evaluation empty, so they were neither evaluated nor redacted before going upstream. Block and redaction decisions may therefore change for routes with large JSON or XML payloads.

This evaluation has a limit worth knowing: only the first `max_body_size_bytes` of a request is evaluated and redacted. Content beyond that point still reaches the upstream service without redaction, and a value that starts before the cutoff and continues past it isn't fully redacted either. Response evaluation isn't affected, since the full response is always sent for evaluation.

### Resolved Issues

#### Redacted request bodies are now exported correctly

When request redaction is on with the AI firewall in sync mode, the request body sent to Traceable is now the redacted version. Previously, the original, unredacted body was sent instead.

#### Large redacted requests now reach the upstream service in full

When request redaction is on with the AI firewall in sync mode, a request larger than `max_body_size_bytes` is now forwarded upstream as the redacted first portion followed by the rest of the original body, instead of being cut off at `max_body_size_bytes` as before. Getting there still means the plugin reads the whole body stored in the temp file into memory first.

#### Cloud metadata attributes are no longer lost

Cloud metadata attributes (`cloud.*` and `instance.aws.*`) are no longer dropped from a worker's exports when a request arrives while the agent is still fetching startup metadata, in either sync or async mode; in async mode they could also be lost if the logging phase was the first to request them. Both cases are fixed.

***

## 2.3.0 - 17<sup>th</sup> August

### Update

#### Added support for AI Firewall in Kong

Kong now supports the AI Firewall. Enable this feature by adding `traceable-ai-extension` to the Kong configuration.

***

## 2.2.2 - 27<sup>th</sup> July

### Updates

#### Added max\_body\_size\_bytes config to control payload size capture

The Kong plugin now supports a `max_body_size_bytes` configuration option that controls the maximum request/response body size captured by the plugin. The default value is `131072` bytes (128 KB), limiting the payload size sent to the Traceable platform. This helps control memory usage and network overhead in high-traffic environments.

***

## 2.2.1 - 22<sup>nd</sup> April

### Updates

#### Added cloud metadata support for Kong running in AWS

The Kong plugin now collects cloud metadata for deployments running in AWS, including ECS, EC2, and EKS environments. Cloud metadata attributes such as `cloud.resource_id` are now captured and included in spans, enabling integrations that rely on cloud context, such as correlating API threats across Traceable and cloud security platforms.

***

## 2.2.0 - 17<sup>th</sup> January

### Updates

#### Added support for a token in the Kong plugin

The Kong plugin now supports configuring a token for authenticating with the Traceable platform. This allows deployments to pass an authentication token as part of the plugin configuration, enabling secure communication with the Traceable collector.

#### Added support for custom service naming using the Kong service name

The Kong plugin can now use the Kong service name as the service identifier in captured spans. This allows you to align the service name reported to Traceable with the service name defined in your Kong configuration, making it easier to correlate API traffic with the correct service in the Traceable platform.

#### Added support for service name prefix

The Kong plugin now supports configuring a prefix for service names reported to the Traceable platform. This allows you to namespace or distinguish service names across multiple environments or deployments by prepending a configurable string to the service name in captured spans.

#### Added Server-Sent Events (SSE) support (disabled by default)

The Kong plugin now includes support for Server-Sent Events (SSE). SSE support is disabled by default and can be enabled via configuration. This allows the plugin to handle SSE-based API traffic when needed, without affecting existing deployments that do not use SSE.

{% @harness-feedback/feedback module="release-notes" pagePath="release-notes/waap-release-notes/2026/agent-release-notes/kong-agent" %}
