tt.conf

# No. of threads to create to handle HTTP connections;
; http.listener.count = 2

# No. of threads to process HTTP requests, per listener;
# For max performance, 'http.listener.count' * 'http.responders.per.listener'
# should at least equal to number of cores on the host;
# If TcpServer is also used, then the sum of both HTTP and TCP
# responders should at least equal to the number of cores on the host.
; http.responders.per.listener = 2

# Max no. of connections each listener can handle;
; http.max.connections.per.listener = 1024

# The format of the HTTP request body is either json or
# plain text (one data point per line, as in TCollector);
; http.request.format = plain

# The HTTP server port number;
; http.server.port = 6182


# Connection timeout, for both TCP and HTTP server;
; tcp.connection.timeout = 10min

# No. of threads to create to handle TCP connections;
tcp.listener.count = 2

# No. of threads to process TCP data, per listener.
# For max performance, 'tcp.listener.count' * 'tcp.responders.per.listener'
# should equal to number of cores on the host;
# Also see 'http.responders.per.listener'.
; tcp.responders.per.listener = 2

# This size needs to be big enough to hold max size of
# HTTP request.
tcp.buffer.size = 1mb

tcp.socket.rcvbuf.size = 1mb

# The TCP server port number;
; tcp.server.port = 6181


# No. of threads to create to handle UDP traffic;
; udp.listener.count = 2

# Max length of a single data point
; udp.max.line = 256


# The number of threads to create to handle queries in parallel.
; query.executor.thread.count = 8

# Size of queue to hold concurrent queries. If the number of
# queries being handled exceed this number, any new query requests
# will failed.
; query.executor.queue.size = 1024


# After this much time the data will be unloaded from memory;
# They are still accessable, just slower because they have to
# be loaded from disk;
; tsdb.archive.threshold = 1w

;tsdb.thrashing.threshold = 1min

# Directory under which to store TSDB data;
tsdb.data.dir = /var/ticktock/data

# No. of pages in each TSDB data file;
# If full, a new TSDB data file will be created;
# 262144 = 2^18
tsdb.page.count = 1024

#tsdb.min.disk.space = 0

# For example, if this is set to 1d, then every day a new
# data file will be created to store data points timestamped
# in that day; Note that multiple data files could be created
# for each day in case one is not enough to hold all the
# data points; the size of each data file is determined by
# 'tsdb.page.count'.
; tsdb.rotation.frequency = 1d

# After this much time a TSDB data file becomes read-only;
# You can still write to it, just slower. Increasing this
# will cause TickTock to use more memory.
; tsdb.read_only.threshold = 1h

# How often should we flush data to disk. Default is 5 minutes.
# Which means you will lose the last 5 minutes of data if the
# server is terminated abnormally. Increasing this frequency
# will have a negative impact on performance, severely if more
# than once a minute.
; tsdb.flush.frequency = 5min

# Resolution of timestamps on data points;
# Either millisecond or second;
# This config can't be changed on existing database;
#tsdb.timestamp.resolution = millisecond
tsdb.timestamp.resolution = millisecond

# Enable collecting TickTock's own metrics.
; tsdb.self_meter.enabled = false


# Directory under which to store append logs;
append.log.dir = /var/ticktock/append

# Enable writing of append logs?
# The last few minutes of data will be lost if append logs are
# disabled. Exactly how much data loss will occur depends on
# the 'tsdb.flush.frequency' setting.
# This config can't be changed on the fly;
; append.log.enabled = false

# How often to flush append logs?
# Note that data that came after last flush may be lost forever.
; append.log.flush.frequency = 2s

# How often to rotate append logs?
; append.log.rotation.frequency = 1h

# How many append logs (per HTTP responder) to keep?
; append.log.retention.count = 2


# Logging level
log.level = INFO

# Log file (full path)
log.file = /var/ticktock/log/ticktock.log

# Log file will be rotated whenever it grows over this size
; log.rotation.size = 10mb

# This number of most recently rotated logs will be kept.
# Older ones will be permanently removed
; log.retention.count = 10


# To enable replication, specify all the replicas as in the following
# config. If "tcp_port" and "http_port" are not specified, they will
# be defaulted to 6181 and 6182 respectively. The order of the servers
# are insignificant. Data can be sent to any of these servers, and
# they will be replicated to all other servers. Define exactly one
# partition with no "from" or "to" (the so called "catch-all" partition).
#
# To enable partition, define partitions with "from" and "to" such that
# all metric names that fall within ["from", "to") alphabetically.
; cluster.servers = [{"id": 0, "address": "172.16.16.100"}, {"id": 1, "address": "172.16.16.101", "tcp_port": 6181, "http_port": 6182}]
; cluster.partitions = [{"from": "a", "to": "n", "servers": [0]}, {"from": "n", "to": "{", "servers": [1]}]