kong.log

This namespace contains an instance of a logging facility, which is a table containing all of the methods described below.

This instance is namespaced per plugin. Before executing a plugin, Kong swaps this instance with a logging facility dedicated to the plugin. This allows the logs to be prefixed with the plugin’s name for debugging purposes.

kong.log(…)

Writes a log line to the location specified by the current Nginx configuration block’s error_log directive, with the notice level (similar to print()).

The Nginx error_log directive is set via the log_level, proxy_error_log and admin_error_log Kong configuration properties.

Arguments given to this function are concatenated similarly to ngx.log(), and the log line reports the Lua file and line number from which it was invoked. Unlike ngx.log(), this function prefixes error messages with [kong] instead of [lua].

Arguments given to this function can be of any type, but table arguments are converted to strings via tostring (thus potentially calling a table’s __tostring metamethod if set). This behavior differs from ngx.log() (which only accepts table arguments if they define the __tostring metamethod) with the intent to simplify its usage and be more forgiving and intuitive.

Produced log lines have the following format when logging is invoked from within the core:

  1.  [kong] %file_src:%line_src %message

In comparison, log lines produced by plugins have the following format:

  1.  [kong] %file_src:%line_src [%namespace] %message

Where:

  • %namespace: The configured namespace (in this case, the plugin name).
  • %file_src: The filename the log was called from.
  • %line_src: The line number the log was called from.
  • %message: The message, made of concatenated arguments given by the caller.

For example, the following call:

  1.  kong.log("hello ", "world")

would, within the core, produce a log line similar to:

  1.  2017/07/09 19:36:25 [notice] 25932#0: *1 [kong] some_file.lua:54 hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

If invoked from within a plugin (for example, key-auth) it would include the namespace prefix:

  1.  2017/07/09 19:36:25 [notice] 25932#0: *1 [kong] some_file.lua:54 [key-auth] hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Parameters

  • … : All parameters will be concatenated and stringified before being sent to the log.

Returns

  • Nothing. Throws an error on invalid inputs.

Usage

  1. kong.log("hello ", "world") -- alias to kong.log.notice()

kong.log.LEVEL(…)

Similar to kong.log(), but the produced log has the severity given by <level>, instead of notice. The supported levels are:

  • kong.log.alert()
  • kong.log.crit()
  • kong.log.err()
  • kong.log.warn()
  • kong.log.notice()
  • kong.log.info()
  • kong.log.debug()

Logs have the same format as that of kong.log(). For example, the following call:

  1.   kong.log.err("hello ", "world")

would, within the core, produce a log line similar to:

  1.  2017/07/09 19:36:25 [error] 25932#0: *1 [kong] some_file.lua:54 hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

If invoked from within a plugin (for example, key-auth) it would include the namespace prefix:

  1.  2017/07/09 19:36:25 [error] 25932#0: *1 [kong] some_file.lua:54 [key-auth] hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Parameters

  • … : All params will be concatenated and stringified before being sent to the log.

Returns

  • Nothing. Throws an error on invalid inputs.

Usage

  1. kong.log.warn("something require attention")
  2. kong.log.err("something failed: ", err)
  3. kong.log.alert("something requires immediate action")

kong.log.deprecation(…)

Write a deprecation log line (similar to kong.log.warn).

Arguments given to this function can be of any type, but table arguments are converted to strings via tostring (thus potentially calling a table’s __tostring metamethod if set). When the last argument is a table, it is considered as a deprecation metadata. The table can include the following properties:

  1.  {
  2.    after = "2.5.0",   -- deprecated after Kong version 2.5.0 (defaults to `nil`)
  3.    removal = "3.0.0", -- about to be removed with Kong version 3.0.0 (defaults to `nil`)
  4.    trace = true,      -- writes stack trace along with the deprecation message (defaults to `nil`)
  5.  }

For example, the following call:

  1.  kong.log.deprecation("hello ", "world")

would, within the core, produce a log line similar to:

  1.  2017/07/09 19:36:25 [warn] 25932#0: *1 [kong] some_file.lua:54 hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

If invoked from within a plugin (for example, key-auth) it would include the namespace prefix:

  1.  2017/07/09 19:36:25 [warn] 25932#0: *1 [kong] some_file.lua:54 [key-auth] hello world, client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

And with metatable, the following call:

  1.  kong.log.deprecation("hello ", "world", { after = "2.5.0", removal = "3.0.0" })

would, within the core, produce a log line similar to:

  1.  2017/07/09 19:36:25 [warn] 25932#0: *1 [kong] some_file.lua:54 hello world (deprecated after 2.5.0, scheduled for removal in 3.0.0), client: 127.0.0.1, server: localhost, request: "GET /log HTTP/1.1", host: "localhost"

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Parameters

  • … : all params will be concatenated and stringified before being sent to the log (if the last param is a table, it is considered as a deprecation metadata)

Returns

  • Nothing; throws an error on invalid inputs.

Usage

  1. kong.log.deprecation("hello ", "world")
  2. kong.log.deprecation("hello ", "world", { after = "2.5.0" })
  3. kong.log.deprecation("hello ", "world", { removal = "3.0.0" })
  4. kong.log.deprecation("hello ", "world", { after = "2.5.0", removal = "3.0.0" })
  5. kong.log.deprecation("hello ", "world", { trace = true })

kong.log.inspect(…)

Like kong.log(), this function produces a log with a notice level and accepts any number of arguments. If inspect logging is disabled via kong.log.inspect.off(), then this function prints nothing, and is aliased to a “NOP” function to save CPU cycles.

This function differs from kong.log() in the sense that arguments will be concatenated with a space(" "), and each argument is pretty-printed:

  • Numbers are printed (e.g. 5 -> "5")
  • Strings are quoted (e.g. "hi" -> '"hi"')
  • Array-like tables are rendered (e.g. {1,2,3} -> "{1, 2, 3}")
  • Dictionary-like tables are rendered on multiple lines

This function is intended for debugging, and usage in production code paths should be avoided due to the expensive formatting operations it can perform. Existing statements can be left in production code but nopped by calling kong.log.inspect.off().

When writing logs, kong.log.inspect() always uses its own format, defined as:

  1.  %file_src:%func_name:%line_src %message

Where:

  • %file_src: The filename the log was called from.
  • %func_name: The name of the function the log was called from.
  • %line_src: The line number the log was called from.
  • %message: The message, made of concatenated, pretty-printed arguments given by the caller.

This function uses the inspect.lua library to pretty-print its arguments.

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Parameters

  • … : Parameters are concatenated with spaces between them and rendered as described.

Usage

  1. kong.log.inspect("some value", a_variable)

kong.log.inspect.on()

Enables inspect logs for this logging facility. Calls to kong.log.inspect will be writing log lines with the appropriate formatting of arguments.

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Usage

  1. kong.log.inspect.on()

kong.log.inspect.off()

Disables inspect logs for this logging facility. All calls to kong.log.inspect() will be nopped.

Phases

  • init_worker, certificate, rewrite, access, header_filter, response, body_filter, log

Usage

  1. kong.log.inspect.off()

kong.log.set_serialize_value(key, value, options)

Sets a value to be used on the serialize custom table.

Logging plugins use the output of kong.log.serialize() as a base for their logs. This function lets you customize the log output.

It can be used to replace existing values in the output, or to delete existing values by passing nil.

Note: The type-checking of the value parameter can take some time, so it is deferred to the serialize() call, which happens in the log phase in most real-usage cases.

Phases

  • certificate, rewrite, access, header_filter, response, body_filter, log

Parameters

  • key (string): The name of the field.
  • value (number|string|boolean|table): Value to be set. When a table is used, its keys must be numbers, strings, or booleans, and its values can be numbers, strings, or other tables like itself, recursively.
  • options (table): Can contain two entries: options.mode can be set (the default, always sets), add (only add if entry does not already exist) and replace (only change value if it already exists).

Returns

  • table: The request information table.

Usage

  1. -- Adds a new value to the serialized table
  2. kong.log.set_serialize_value("my_new_value", 1)
  3. assert(kong.log.serialize().my_new_value == 1)
  5. -- Value can be a table
  6. kong.log.set_serialize_value("my", { new = { value = 2 } })
  7. assert(kong.log.serialize().my.new.value == 2)
  9. -- It is possible to change an existing serialized value
  10. kong.log.set_serialize_value("my_new_value", 3)
  11. assert(kong.log.serialize().my_new_value == 3)
  13. -- Unset an existing value by setting it to nil
  14. kong.log.set_serialize_value("my_new_value", nil)
  15. assert(kong.log.serialize().my_new_value == nil)
  17. -- Dots in the key are interpreted as table accesses
  18. kong.log.set_serialize_value("my.new.value", 4)
  19. assert(kong.log.serialize().my.new_value == 4)

kong.log.serialize()

Generates a table with useful information for logging.

This method can be used in the http subsystem.

The following fields are included in the returned table:

  • client_ip - client IP address in textual format.
  • latencies - request/proxy latencies.
  • request.headers - request headers.
  • request.method - request method.
  • request.querystring - request query strings.
  • request.size - size of request.
  • request.url and request.uri - URL and URI of request.
  • response.headers - response headers.
  • response.size - size of response.
  • response.status - response HTTP status code.
  • route - route object matched.
  • service - service object used.
  • started_at - timestamp this request came in, in milliseconds.
  • tries - Upstream information; this is an array and if any balancer retries occurred, will contain more than one entry.
  • upstream_uri - request URI sent to Upstream.

The following fields are only present in an authenticated request (with consumer):

  • authenticated_entity - credential used for authentication.
  • consumer - consumer entity accessing the resource.

The following fields are only present in a TLS/HTTPS request:

  • request.tls.version - TLS/SSL version used by the connection.
  • request.tls.cipher - TLS/SSL cipher used by the connection.
  • request.tls.client_verify - mTLS validation result. Contents are the same as described in $ssl_client_verify.

Warning: This function may return sensitive data (e.g., API keys). Consider filtering before writing it to unsecured locations.

All fields in the returned table may be altered using kong.log.set_serialize_value.

The following HTTP authentication headers are redacted by default, if they appear in the request:

  • request.headers.authorization
  • request.headers.proxy-authorization

To see what content is present in your setup, enable any of the logging plugins (e.g., file-log) and the output written to the log file is the table returned by this function JSON-encoded.

Phases

  • log

Returns

  • table: the request information table

Usage

  1. kong.log.serialize()