emqx4.3/rel/i18n/emqx_conf_schema.hocon

emqx_conf_schema {

log_root.desc =
    """~
    EMQX provides support for two primary log handlers: `file` and `console`, with an additional `audit` handler specifically designed to always direct logs to files.
    The system's default log handling behavior can be configured via the environment variable `EMQX_DEFAULT_LOG_HANDLER`, which accepts the following settings:

    - `file`: Directs log output exclusively to files.
    - `console`: Channels log output solely to the console.

    It's noteworthy that `EMQX_DEFAULT_LOG_HANDLER` is set to `file` when EMQX is initiated via systemd's `emqx.service` file.
    In scenarios outside systemd initiation, `console` serves as the default log handler."""

log_root.label = log

common_handler_drop_mode_qlen.desc:
"""When the number of buffered log events is larger than this value, the new log events are dropped.
When drop mode is activated or deactivated, a message is printed in the logs."""

common_handler_drop_mode_qlen.label:
"""Queue Length before Entering Drop Mode"""

desc_cluster_dns.desc:
"""Service discovery via DNS SRV records."""

desc_cluster_dns.label:
"""Cluster DNS"""

cluster_dns_name.desc:
"""The domain name from which to discover peer EMQX nodes' IP addresses.
Applicable when <code>cluster.discovery_strategy = dns</code>"""

cluster_dns_name.label:
"""Cluster Dns Name"""

rpc_keyfile.desc:
"""Path to the private key file for the <code>rpc.certfile</code>.<br/>
Note: contents of this file are secret, so it's necessary to set permissions to 600."""

rpc_keyfile.label:
"""RPC Keyfile"""

cluster_autoheal.desc:
"""If <code>true</code>, the node will try to heal network partitions automatically."""

cluster_autoheal.label:
"""Cluster Auto Heal"""

log_overload_kill_enable.desc:
"""Enable log handler overload kill feature."""

log_overload_kill_enable.label:
"""Log Handler Overload Kill"""

node_etc_dir.desc:
"""<code>etc</code> dir for the node"""

node_etc_dir.label:
"""Etc Dir"""

cluster_proto_dist.desc:
"""The Erlang distribution protocol for the cluster.<br/>
- inet_tcp: IPv4 TCP <br/>
- inet_tls: IPv4 TLS, works together with <code>etc/ssl_dist.conf</code> <br/>
- inet6_tcp: IPv6 TCP <br/>
- inet6_tls: IPv6 TLS, works together with <code>etc/ssl_dist.conf</code>"""

cluster_proto_dist.label:
"""Cluster Protocol Distribution"""

log_burst_limit_enable.desc:
"""Enable log burst control feature."""

log_burst_limit_enable.label:
"""Enable Burst"""

dist_buffer_size.desc:
"""Erlang's distribution buffer busy limit in kilobytes."""

dist_buffer_size.label:
"""Erlang's dist buffer size(KB)"""

common_handler_max_depth.desc:
"""Maximum depth for Erlang term log formatting and Erlang process message queue inspection."""

common_handler_max_depth.label:
"""Max Depth"""

desc_log.desc:
"""EMQX supports multiple log handlers, one console handler and multiple file handlers.
EMQX by default logs to console when running in docker or in console/foreground mode,
otherwise it logs to file $EMQX_LOG_DIR/emqx.log.
For advanced configuration, you can find more parameters in this section."""

desc_log.label:
"""Log"""

common_handler_flush_qlen.desc:
"""If the number of buffered log events grows larger than this threshold, a flush (delete) operation takes place.
To flush events, the handler discards the buffered log messages without logging."""

common_handler_flush_qlen.label:
"""Flush Threshold"""

common_handler_chars_limit.desc:
"""Set the maximum length of a single log message. If this length is exceeded, the log message will be truncated.
When formatter is <code>json</code> the truncation is done on the JSON values, but not on the log message itself."""

common_handler_chars_limit.label:
"""Single Log Max Length"""

cluster_k8s_namespace.desc:
"""Kubernetes namespace."""

cluster_k8s_namespace.label:
"""K8s Namespace"""

node_name.desc:
"""Unique name of the EMQX node. It must follow <code>%name%@FQDN</code> or
<code>%name%@IPv4</code> format."""

node_name.label:
"""Node Name"""

rpc_port_discovery.desc:
"""<code>manual</code>: discover ports by <code>tcp_server_port</code>.<br/>
<code>stateless</code>: discover ports in a stateless manner, using the following algorithm.
If node name is <code>emqxN@127.0.0.1</code>, where the N is an integer,
then the listening port will be 5370 + N."""

rpc_port_discovery.label:
"""RRC Port Discovery"""

log_overload_kill_restart_after.desc:
"""The handler restarts automatically after a delay in the event of termination, unless the value `infinity` is set, which blocks any subsequent restarts."""

log_overload_kill_restart_after.label:
"""Handler Restart Timer"""

log_file_handler_max_size.desc:
"""This parameter controls log file rotation. The value `infinity` means the log file will grow indefinitely, otherwise the log file will be rotated once it reaches `rotation_size` in bytes."""

log_file_handler_max_size.label:
"""Rotation Size"""

desc_log_file_handler.desc:
"""Log handler that prints log events to files."""

desc_log_file_handler.label:
"""Files Log Handler"""

desc_audit_log_handler.desc:
"""Audit log handler that prints log events to files."""

desc_audit_log_handler.label:
"""Audit Log Handler"""

rpc_socket_keepalive_count.desc:
"""How many times the keepalive probe message can fail to receive a reply
until the RPC connection is considered lost."""

rpc_socket_keepalive_count.label:
"""RPC Socket Keepalive Count"""

cluster_etcd_server.desc:
"""List of endpoint URLs of the etcd cluster"""

cluster_etcd_server.label:
"""Cluster Etcd Server"""

db_backend.desc:
"""Select the backend for the embedded database.<br/>
<code>rlog</code> is the default backend,
that is suitable for very large clusters.<br/>
<code>mnesia</code> is a backend that offers decent performance in small clusters."""

db_backend.label:
"""DB Backend"""

desc_authorization.desc:
"""Settings that control client authorization."""

desc_authorization.label:
"""Authorization"""

cluster_etcd_ssl.desc:
"""Options for the TLS connection to the etcd cluster."""

cluster_etcd_ssl.label:
"""Cluster Etcd SSL Option"""

rpc_insecure_fallback.desc:
"""Enable compatibility with old RPC authentication."""

rpc_insecure_fallback.label:
"""RPC insecure fallback"""

rpc_listen_address.desc:
"""Indicates the IP address for the RPC server to listen on. For example, use <code>"0.0.0.0"</code> for IPv4 or <code>"::"</code> for IPv6."""

rpc_listen_address.label:
"""RPC Listen IP Address"""

rpc_ipv6_only.desc:
"""This setting is effective only when <code>rpc.listen_address</code> is assigned an IPv6 address.
If set to <code>true</code>, the RPC client will exclusively use IPv6 for connections.
Otherwise, the client might opt for IPv4, even if the server is on IPv6."""

rpc_ipv6_only.label:
"""Use IPv6 Only"""

rpc_authentication_timeout.desc:
"""Timeout for the remote node authentication."""

rpc_authentication_timeout.label:
"""RPC Authentication Timeout"""

cluster_call_retry_interval.desc:
"""Time interval to retry after a failed call."""

cluster_call_retry_interval.label:
"""Cluster Call Retry Interval"""

rpc_driver.desc:
"""Transport protocol used for inter-broker communication"""

rpc_driver.label:
"""RPC dirver"""

max_ets_tables.desc:
"""Max number of ETS tables"""

max_ets_tables.label:
"""Max number of ETS tables"""

desc_db.desc:
"""Settings for the embedded database."""

desc_db.label:
"""Database"""

desc_cluster_etcd.desc:
"""Service discovery using 'etcd' service."""

desc_cluster_etcd.label:
"""Cluster Etcd"""

cluster_name.desc:
"""Human-friendly name of the EMQX cluster."""

cluster_name.label:
"""Cluster Name"""

log_rotation_enable.desc:
"""Enable log rotation feature."""

log_rotation_enable.label:
"""Rotation Enable"""

cluster_call_cleanup_interval.desc:
"""Time interval to clear completed but stale transactions.
Ensure that the number of completed transactions is less than the <code>max_history</code>."""

cluster_call_cleanup_interval.label:
"""Clean Up Interval"""

desc_cluster_static.desc:
"""Service discovery via static nodes.
The new node joins the cluster by connecting to one of the bootstrap nodes."""

desc_cluster_static.label:
"""Cluster Static"""

db_default_shard_transport.desc:
"""Defines the default transport for pushing transaction logs.<br/>
This may be overridden on a per-shard basis in <code>db.shard_transports</code>.
<code>gen_rpc</code> uses the <code>gen_rpc</code> library,
<code>distr</code> uses the Erlang distribution."""

db_default_shard_transport.label:
"""Default Shard Transport"""

cluster_static_seeds.desc:
"""List EMQX node names in the static cluster. See <code>node.name</code>."""

cluster_static_seeds.label:
"""Cluster Static Seeds"""

log_overload_kill_qlen.desc:
"""Maximum allowed queue length."""

log_overload_kill_qlen.label:
"""Max Queue Length"""

node_backtrace_depth.desc:
"""Maximum depth of the call stack printed in error messages and
<code>process_info</code>."""

node_backtrace_depth.label:
"""BackTrace Depth"""

desc_log_burst_limit.desc:
"""Large bursts of log events produced in a short time can potentially cause problems, such as:
 - Log files grow very large
 - Log files are rotated too quickly, and useful information gets overwritten
 - Overall performance impact on the system

Log burst limit feature can temporarily disable logging to avoid these issues."""

desc_log_burst_limit.label:
"""Log Burst Limit"""

common_handler_enable.desc:
"""Enable this log handler."""

common_handler_enable.label:
"""Enable Log Handler"""

cluster_k8s_service_name.desc:
"""EMQX broker service name."""

cluster_k8s_service_name.label:
"""K8s Service Name"""

log_rotation_count.desc:
"""Maximum number of log files."""

log_rotation_count.label:
"""Max Log Files Number"""

node_cookie.desc:
"""Secret cookie is a random string that should be the same on all nodes in
the given EMQX cluster, but unique per EMQX cluster. It is used to prevent EMQX nodes that
belong to different clusters from accidentally connecting to each other."""

node_cookie.label:
"""Node Cookie"""

db_role.desc:
"""Select a node role.<br/>
<code>core</code> nodes provide durability of the data, and take care of writes.
It is recommended to place core nodes in different racks or different availability zones.<br/>
<code>replicant</code> nodes are ephemeral worker nodes. Removing them from the cluster
doesn't affect database redundancy<br/>
It is recommended to have more replicant nodes than core nodes.<br/>
Note: this parameter only takes effect when the <code>backend</code> is set
to <code>rlog</code>."""

db_role.label:
"""DB Role"""

rpc_tcp_server_port.desc:
"""Listening port used by RPC local service.<br/>
Note that this config only takes effect when rpc.port_discovery is set to manual."""

rpc_tcp_server_port.label:
"""RPC TCP Server Port"""

desc_console_handler.desc:
"""Log handler that prints log events to the EMQX console."""

desc_console_handler.label:
"""Console Handler"""

node_applications.desc:
"""List of Erlang applications that shall be rebooted when the EMQX broker joins the cluster."""

node_applications.label:
"""Application"""

log_burst_limit_max_count.desc:
"""Maximum number of log events to handle within a `window_time` interval. After the limit is reached, successive events are dropped until the end of the `window_time`."""

log_burst_limit_max_count.label:
"""Events Number"""

rpc_tcp_client_num.desc:
"""Set the maximum number of RPC communication channels initiated by this node to each remote node."""

rpc_tcp_client_num.label:
"""RPC TCP Client Num"""

cluster_k8s_address_type.desc:
"""Address type used for connecting to the discovered nodes.
Setting <code>cluster.k8s.address_type</code> to <code>ip</code> will
make EMQX to discover IP addresses of peer nodes from Kubernetes API."""

cluster_k8s_address_type.label:
"""K8s Address Type"""

rpc_socket_sndbuf.desc:
"""TCP tuning parameters. TCP sending buffer size."""

rpc_socket_sndbuf.label:
"""RPC Socket Sndbuf"""

log_file_handler_file.desc:
"""Name the log file."""

log_file_handler_file.label:
"""Log File Name"""

audit_file_handler_path.desc:
"""Name the audit log file."""

audit_file_handler_path.label:
"""Audit Log File Name"""

node_dist_net_ticktime.desc:
"""This is the approximate time an EMQX node may be unresponsive until it is considered down and thereby disconnected."""

node_dist_net_ticktime.label:
"""Dist Net TickTime"""

desc_cluster_k8s.desc:
"""Service discovery via Kubernetes API server."""

desc_cluster_k8s.label:
"""Cluster Kubernetes"""

rpc_cacertfile.desc:
"""Path to certification authority TLS certificate file used to validate <code>rpc.certfile</code>.<br/>
Note: certificates of all nodes in the cluster must be signed by the same CA."""

rpc_cacertfile.label:
"""RPC Cacertfile"""

desc_node.desc:
"""Node name, cookie, config & data directories and the Erlang virtual machine (BEAM) boot parameters."""

desc_node.label:
"""Node"""

cluster_k8s_apiserver.desc:
"""Kubernetes API endpoint URL."""

cluster_k8s_apiserver.label:
"""Cluster k8s ApiServer"""

common_handler_supervisor_reports.desc:
"""Type of supervisor reports that are logged. Defaults to <code>error</code><br/>
  - <code>error</code>: only log errors in the Erlang processes<br/>.
  - <code>progress</code>: log process startup."""

common_handler_supervisor_reports.label:
"""Report Type"""

node_data_dir.desc:
"""Path to the persistent data directory.<br/>
Possible auto-created subdirectories are:<br/>
- `mnesia/<node_name>`: EMQX's built-in database directory.<br/>
For example, `mnesia/emqx@127.0.0.1`.<br/>
There should be only one such subdirectory.<br/>
Meaning, in case the node is to be renamed (to e.g. `emqx@10.0.1.1`),<br/>
the old dir should be deleted first.<br/>
- `configs`: Generated configs at boot time, and cluster/local override configs.<br/>
- `patches`: Hot-patch beam files are to be placed here.<br/>
- `trace`: Trace log files.<br/>

**NOTE**: One data dir cannot be shared by two or more EMQX nodes."""

node_data_dir.label:
"""Node Data Dir"""

cluster_k8s_suffix.desc:
"""Node name suffix.<br/>
Note: this parameter is only relevant when <code>address_type</code> is <code>dns</code>
or <code>hostname</code>."""

cluster_k8s_suffix.label:
"""K8s Suffix"""

db_rpc_module.desc:
"""Protocol used for pushing transaction logs to the replicant nodes."""

db_rpc_module.label:
"""RPC Module"""

cluster_etcd_prefix.desc:
"""Key prefix used for EMQX service discovery."""

cluster_etcd_prefix.label:
"""Cluster Etcd Prefix"""

log_burst_limit_window_time.desc:
"""See <code>max_count</code>."""

log_burst_limit_window_time.label:
"""Window Time"""

desc_log_throttling.label:
"""Log Throttling"""

desc_log_throttling.desc:
"""Log throttling feature reduces the number of potentially flooding logged events by
dropping all but the first event within a configured time window.
The throttling is automatically disabled if `console` or `file` log level is set to debug."""

log_throttling_time_window.desc: """~
    This configuration setting controls the logging behavior for throttled messages,
    including, but not limited to messages like 'authorization_permission_denied'.
    Within each defined time window, only one instance of a throttled message will be logged to prevent log flooding.
    At the conclusion of each time window, a summary log will be generated, detailing the occurrence of any throttled messages during that period.
    It's important to note that the shortest effective time window for this setting is 1 second (`1s`).
    Should a value lower than `1s` be specified, it will automatically be adjusted to `1s`.~"""

log_throttling_time_window.label:
"""Log Throttling Time Window"""

cluster_dns_record_type.desc:
"""DNS record type."""

cluster_dns_record_type.label:
"""DNS Record Type"""

cluster_autoclean.desc:
"""Remove disconnected nodes from the cluster after this interval."""

cluster_autoclean.label:
"""Cluster Auto Clean"""

process_limit.desc:
"""Maximum number of simultaneously existing processes for this Erlang system.
For more information, see: https://www.erlang.org/doc/man/erl.html"""

process_limit.label:
"""Erlang Process Limit"""

max_ports.desc:
"""Maximum number of simultaneously open files and sockets for this Erlang system.
For more information, see: https://www.erlang.org/doc/man/erl.html"""

max_ports.label:
"""Erlang Port Limit"""

desc_log_rotation.desc:
"""By default, the logs are stored in `./log` directory (for installation from zip file) or in `/var/log/emqx` (for binary installation).<br/>
This section of the configuration controls the number of files kept for each log handler."""

desc_log_rotation.label:
"""Log Rotation"""

desc_log_overload_kill.desc:
"""Log overload kill features an overload protection that activates when the log handlers use too much memory or have too many buffered log messages.<br/>
When the overload is detected, the log handler is terminated and restarted after a cooldown period."""

desc_log_overload_kill.label:
"""Log Overload Kill"""

authorization.desc:
"""Authorization a.k.a. ACL.<br/>
In EMQX, MQTT client access control is extremely flexible.<br/>
An out-of-the-box set of authorization data sources are supported.
For example,<br/>
'file' source is to support concise and yet generic ACL rules in a file;<br/>
'built_in_database' source can be used to store per-client customizable rule sets,
natively in the EMQX node;<br/>
'http' source to make EMQX call an external HTTP API to make the decision;<br/>
'PostgreSQL' etc. to look up clients or rules from external databases"""

authorization.label:
"""Authorization"""

rpc_socket_keepalive_idle.desc:
"""How long the connections between the brokers should remain open after the last message is sent."""

rpc_socket_keepalive_idle.label:
"""RPC Socket Keepalive Idle"""

desc_cluster_call.desc:
"""Options for the 'cluster call' feature that allows to execute a callback on all nodes in the cluster."""

desc_cluster_call.label:
"""Cluster Call"""

log_overload_kill_mem_size.desc:
"""Maximum memory size that the log handler process is allowed to use."""

log_overload_kill_mem_size.label:
"""Log Handler Max Memory Size"""

rpc_connect_timeout.desc:
"""Timeout for establishing an RPC connection."""

rpc_connect_timeout.label:
"""RPC Connect Timeout"""

cluster_etcd_node_ttl.desc:
"""Expiration time of the etcd key associated with the node.
It is refreshed automatically, as long as the node is alive."""

cluster_etcd_node_ttl.label:
"""Cluster Etcd Node TTL"""

rpc_call_receive_timeout.desc:
"""Timeout for the reply to a synchronous RPC."""

rpc_call_receive_timeout.label:
"""RPC Call Receive Timeout"""

rpc_socket_recbuf.desc:
"""TCP tuning parameters. TCP receiving buffer size."""

rpc_socket_recbuf.label:
"""RPC Socket Recbuf"""

db_tlog_push_mode.desc:
"""In sync mode the core node waits for an ack from the replicant nodes before sending the next
transaction log entry."""

db_tlog_push_mode.label:
"""Tlog Push Mode"""

node_crash_dump_bytes.desc:
"""This variable sets the maximum size of a crash dump file in bytes.
The crash dump will be truncated if this limit is exceeded.
If setting it to 0, the runtime system does not even attempt to write a crash dump file."""

node_crash_dump_bytes.label:
"""Crash Dump Bytes"""

rpc_certfile.desc:
"""Path to TLS certificate file used to validate identity of the cluster nodes.
Note that this config only takes effect when <code>rpc.driver</code> is set to <code>ssl</code>."""

rpc_certfile.label:
"""RPC Certfile"""

node_crash_dump_seconds.desc:
"""This variable gives the number of seconds that the emulator is allowed to spend writing a crash dump. When the given number of seconds have elapsed, the emulator is terminated.<br/>
- If setting to 0 seconds, the runtime system does not even attempt to write the crash dump file. It only terminates.<br/>
- If setting to a positive value S, wait for S seconds to complete the crash dump file and then terminates the runtime system with a SIGALRM signal.<br/>
- A negative value causes the termination of the runtime system to wait indefinitely until the crash dump file has been completely written."""

node_crash_dump_seconds.label:
"""Crash Dump Seconds"""

log_file_handlers.desc:
"""File-based log handlers."""

log_file_handlers.label:
"""File Handler"""

log_audit_handler.desc:
"""Audit file-based log handler."""

log_audit_handler.label:
"""Audit log Handler"""

node_global_gc_interval.desc:
"""Periodic garbage collection interval. Set to <code>disabled</code> to have it disabled."""

node_global_gc_interval.label:
"""Global GC Interval"""

common_handler_time_offset.desc:
"""The time offset to be used when formatting the timestamp.
Can be one of:
  - <code>system</code>: the time offset used by the local system
  - <code>utc</code>: the UTC time offset
  - <code>+-[hh]:[mm]</code>: user specified time offset, such as "-02:00" or "+00:00"
Defaults to: <code>system</code>.
This config has no effect for when formatter is <code>json</code> as the timestamp in JSON is milliseconds since epoch."""

common_handler_time_offset.label:
"""Time Offset"""

rpc_mode.desc:
"""In <code>sync</code> mode the sending side waits for the ack from the receiving side."""

rpc_mode.label:
"""RPC Mode"""

node_crash_dump_file.desc:
"""Location of the crash dump file."""

node_crash_dump_file.label:
"""Crash Dump File"""

rpc_socket_keepalive_interval.desc:
"""The interval between keepalive messages."""

rpc_socket_keepalive_interval.label:
"""RPC Socket Keepalive Interval"""

common_handler_level.desc:
"""The log level for the current log handler.
Defaults to warning."""

common_handler_level.label:
"""Log Level"""

audit_handler_level.desc:
"""The log level for the audit log handler.<br/>
- Requests that take longer than 3 seconds to process are logged as <code>warning</code> logs.<br/>
- GET requests with HTTP status codes between 200-300 are logged as <code>debug</code> logs.<br/>
- Non-GET Requests with HTTP status codes between 200-300 are logged as <code>info</code> logs.<br/>
- Requests with HTTP status codes between 300-400 are logged as <code>warning</code> logs.<br/>
- Requests with HTTP status codes between 400-500 are logged as <code>error</code> logs.<br/>
- Defaults to info."""

audit_handler_level.label:
"""Log Level"""

audit_log_max_filter_limit.desc:
"""Store the latest N log entries in a database for allow `/audit` HTTP API to filter and retrieval of log data.
The interval for purging redundant log records is maintained within a range of 10~20 seconds."""

audit_log_max_filter_limit.label:
"""Max Filter Limit"""

audit_log_ignore_high_frequency_request.desc:
"""Ignore high frequency requests to avoid flooding the audit log,
such as publish/subscribe kick out http api requests are ignored."""

audit_log_ignore_high_frequency_request.label:
"""Ignore High Frequency Request"""

desc_rpc.desc:
"""EMQX uses a library called <code>gen_rpc</code> for inter-broker communication.<br/>
Most of the time the default config should work,
but in case you need to do performance fine-tuning or experiment a bit,
this is where to look."""

desc_rpc.label:
"""RPC"""

rpc_ssl_server_port.desc:
"""Listening port used by RPC local service.<br/>
Note that this config only takes effect when rpc.port_discovery is set to manual
and <code>driver</code> is set to <code>ssl</code>."""

rpc_ssl_server_port.label:
"""RPC SSL Server Port"""

desc_cluster.desc:
"""EMQX nodes can form a cluster to scale up the total capacity.<br/>
      Here holds the configs to instruct how individual nodes can discover each other."""

desc_cluster.label:
"""Cluster"""

common_handler_sync_mode_qlen.desc:
"""As long as the number of buffered log events is lower than this value,
all log events are handled asynchronously. This means that the client process sending the log event,
by calling a log function in the Logger API, does not wait for a response from the handler
but continues executing immediately after the event is sent.
It is not affected by the time it takes the handler to print the event to the log device.
If the message queue grows larger than this value,
the handler starts handling log events synchronously instead,
meaning that the client process sending the event must wait for a response.
When the handler reduces the message queue to a level below the sync_mode_qlen threshold,
asynchronous operation is resumed."""

common_handler_sync_mode_qlen.label:
"""Queue Length before Entering Sync Mode"""

common_handler_formatter.desc:
"""Choose log formatter. <code>text</code> for free text, and <code>json</code> for structured logging."""

common_handler_formatter.label:
"""Log Formatter"""

common_handler_timestamp_format.label:
"""Timestamp Format"""

common_handler_timestamp_format.desc: """~
    Pick a timestamp format:
    - `auto`: automatically choose the best format based on log formatter. `epoch` for JSON and `rfc3339` for text.
    - `epoch`: Unix epoch time in microseconds.
    - `rfc3339`: RFC3339 format."""

rpc_async_batch_size.desc:
"""The maximum number of batch messages sent in asynchronous mode.
      Note that this configuration does not work in synchronous mode."""

rpc_async_batch_size.label:
"""Async Batch Size"""

cluster_call_max_history.desc:
"""Retain the maximum number of completed transactions (for queries)."""

cluster_call_max_history.label:
"""Cluster Call Max History"""

cluster_discovery_strategy.desc:
"""Service discovery method for the cluster nodes. Possible values are:
- manual: Use <code>emqx ctl cluster</code> command to manage cluster.<br/>
- static: Configure static nodes list by setting <code>seeds</code> in config file.<br/>
- dns: Use DNS A record to discover peer nodes.<br/>
- etcd: Use etcd to discover peer nodes.<br/>
- k8s: Use Kubernetes API to discover peer pods."""

cluster_discovery_strategy.label:
"""Cluster Discovery Strategy"""

rpc_send_timeout.desc:
"""Timeout for sending the RPC request."""

rpc_send_timeout.label:
"""RPC Send Timeout"""

common_handler_single_line.desc:
"""Print logs in a single line if set to true. Otherwise, log messages may span multiple lines."""

common_handler_single_line.label:
"""Single Line Mode"""

rpc_socket_buffer.desc:
"""TCP tuning parameters. Socket buffer size in user mode."""

rpc_socket_buffer.label:
"""RPC Socket Buffer"""

db_shard_transports.desc:
"""Allows to tune the transport method used for transaction log replication, on a per-shard basis.<br/>
<code>gen_rpc</code> uses the <code>gen_rpc</code> library,
<code>distr</code> uses the Erlang distribution.<br/>If not specified,
the default is to use the value set in <code>db.default_shard_transport</code>."""

db_shard_transports.label:
"""Shard Transports"""

db_default_bootstrap_batch_size.desc:
"""The number of built-in database table records to be pushed in one chunk from a core node to a replicant node during bootstrap.
The bootstrapping occurs when a new replicant node is added to the cluster or an existing replicant node reconnects to a core one.
Increasing this value may greatly reduce a replicant node startup time, especially when EMQX cluster interconnect network latency is high
and EMQX built-in database holds large amount of data, e.g. when the number of subscriptions is high.
Defaults to 500."""

db_default_bootstrap_batch_size.label:
"""Default Bootstrap Batch Size"""

node_broker_pool_size.desc:
"""The number of workers in emqx_broker pool. Increasing this value may improve performance
by enhancing parallelism, especially when EMQX cluster interconnect network latency is high.
Defaults to the number of Erlang schedulers (CPU cores) * 2."""

node_broker_pool_size.label:
"""Node Broker Pool Size"""

node_generic_pool_size.desc:
"""The number of workers in emqx_pool. Increasing this value may improve performance
by enhancing parallelism, especially when EMQX cluster interconnect network latency is high.
Defaults to the number of Erlang schedulers (CPU cores)."""

node_generic_pool_size.label:
"""Node Generic Pool Size"""

node_channel_cleanup_batch_size.desc:
"""The size of the channel cleanup batch. if EMQX cluster interconnect network latency is high,
reducing this value together with increasing node.generic_pool_size may improve performance
during an abrupt disconnect of a large numbers of clients.
Defaults to 100000."""

node_channel_cleanup_batch_size.label:
"""Node Channel Cleanup Batch Size"""

}