Rule Engine Configuration

All parameters listed here correspond to settings in tb-edge.yml (or tb-edge.conf on Linux). Set them as environment variables in /etc/tb-edge/conf/tb-edge.conf (Linux) or as container environment variables (Docker / Kubernetes). For instructions on applying changes, see How to change configuration.

Actor system parameters

Parameter	Env variable	Default	Description
`actors.system.throughput`	`ACTORS_SYSTEM_THROUGHPUT`	`5`	Number of messages the actor system will process per actor before switching to processing of messages for the next actor
`actors.system.scheduler_pool_size`	`ACTORS_SYSTEM_SCHEDULER_POOL_SIZE`	`1`	Thread pool size for actor system scheduler
`actors.system.max_actor_init_attempts`	`ACTORS_SYSTEM_MAX_ACTOR_INIT_ATTEMPTS`	`10`	Maximum number of attempts to init the actor before disabling the actor
`actors.system.app_dispatcher_pool_size`	`ACTORS_SYSTEM_APP_DISPATCHER_POOL_SIZE`	`1`	Thread pool size for main actor system dispatcher
`actors.system.tenant_dispatcher_pool_size`	`ACTORS_SYSTEM_TENANT_DISPATCHER_POOL_SIZE`	`2`	Thread pool size for actor system dispatcher that process messages for tenant actors
`actors.system.device_dispatcher_pool_size`	`ACTORS_SYSTEM_DEVICE_DISPATCHER_POOL_SIZE`	`4`	Thread pool size for actor system dispatcher that process messages for device actors
`actors.system.rule_dispatcher_pool_size`	`ACTORS_SYSTEM_RULE_DISPATCHER_POOL_SIZE`	`8`	Thread pool size for actor system dispatcher that process messages for rule engine (chain/node) actors
`actors.system.edge_dispatcher_pool_size`	`ACTORS_SYSTEM_EDGE_DISPATCHER_POOL_SIZE`	`4`	Thread pool size for actor system dispatcher that process messages for edge actors
`actors.tenant.create_components_on_init`	`ACTORS_TENANT_CREATE_COMPONENTS_ON_INIT`	`true`	Create components in initialization
`actors.session.max_concurrent_sessions_per_device`	`ACTORS_MAX_CONCURRENT_SESSION_PER_DEVICE`	`1`	Max number of concurrent sessions per device
`actors.session.sync.timeout`	`ACTORS_SESSION_SYNC_TIMEOUT`	`10000`	Default timeout for processing requests using synchronous session (HTTP, CoAP) in milliseconds
`actors.rule.db_callback_thread_pool_size`	`ACTORS_RULE_DB_CALLBACK_THREAD_POOL_SIZE`	`50`	Specify thread pool size for database request callbacks executor service
`actors.rule.mail_thread_pool_size`	`ACTORS_RULE_MAIL_THREAD_POOL_SIZE`	`40`	Specify thread pool size for mail sender executor service
`actors.rule.mail_password_reset_thread_pool_size`	`ACTORS_RULE_MAIL_PASSWORD_RESET_THREAD_POOL_SIZE`	`10`	Specify thread pool size for password reset emails
`actors.rule.sms_thread_pool_size`	`ACTORS_RULE_SMS_THREAD_POOL_SIZE`	`50`	Specify thread pool size for sms sender executor service
`actors.rule.allow_system_mail_service`	`ACTORS_RULE_ALLOW_SYSTEM_MAIL_SERVICE`	`true`	Whether to allow usage of system mail service for rules
`actors.rule.allow_system_sms_service`	`ACTORS_RULE_ALLOW_SYSTEM_SMS_SERVICE`	`true`	Whether to allow usage of system sms service for rules
`actors.rule.external_call_thread_pool_size`	`ACTORS_RULE_EXTERNAL_CALL_THREAD_POOL_SIZE`	`50`	Specify thread pool size for external call service
`actors.rule.chain.error_persist_frequency`	`ACTORS_RULE_CHAIN_ERROR_FREQUENCY`	`3000`	Errors for particular actors are persisted once per specified amount of milliseconds
`actors.rule.chain.debug_mode_rate_limits_per_tenant.enabled`	`ACTORS_RULE_CHAIN_DEBUG_MODE_RATE_LIMITS_PER_TENANT_ENABLED`	`true`	Enable/Disable the rate limit of persisted debug events for all rule nodes per tenant
`actors.rule.chain.debug_mode_rate_limits_per_tenant.configuration`	`ACTORS_RULE_CHAIN_DEBUG_MODE_RATE_LIMITS_PER_TENANT_CONFIGURATION`	`50000:3600`	The value of DEBUG mode rate limit. By default, no more then 50 thousand events per hour
`actors.rule.node.error_persist_frequency`	`ACTORS_RULE_NODE_ERROR_FREQUENCY`	`3000`	Errors for particular actor are persisted once per specified amount of milliseconds
`actors.rule.transaction.queue_size`	`ACTORS_RULE_TRANSACTION_QUEUE_SIZE`	`15000`	Size of queues that store messages for transaction rule nodes
`actors.rule.transaction.duration`	`ACTORS_RULE_TRANSACTION_DURATION`	`60000`	Time in milliseconds for transaction to complete
`actors.rule.external.force_ack`	`ACTORS_RULE_EXTERNAL_NODE_FORCE_ACK`	`false`	Force acknowledgment of the incoming message for external rule nodes to decrease processing latency. Enqueue the result of external node processing as a separate message to the rule engine.
`actors.rpc.max_retries`	`ACTORS_RPC_MAX_RETRIES`	`5`	Maximum number of persistent RPC call retries in case of failed request delivery.
`actors.rpc.submit_strategy`	`ACTORS_RPC_SUBMIT_STRATEGY_TYPE`	`BURST`	RPC submit strategies. Allowed values: BURST, SEQUENTIAL_ON_ACK_FROM_DEVICE, SEQUENTIAL_ON_RESPONSE_FROM_DEVICE.
`actors.rpc.response_timeout_ms`	`ACTORS_RPC_RESPONSE_TIMEOUT_MS`	`30000`	Time in milliseconds for RPC to receive a response after delivery. Used only for SEQUENTIAL_ON_RESPONSE_FROM_DEVICE submit strategy.
`actors.statistics.enabled`	`ACTORS_STATISTICS_ENABLED`	`true`	Enable/disable actor statistics
`actors.statistics.persist_frequency`	`ACTORS_STATISTICS_PERSIST_FREQUENCY`	`3600000`	Actors statistic persistence frequency in milliseconds

Queue configuration parameters

Parameter	Env variable	Default	Description
`queue.type`	`TB_QUEUE_TYPE`	`in-memory`	in-memory or kafka (Apache Kafka)
`queue.cloud-event.topic`	`TB_QUEUE_CLOUD_EVENT_TOPIC`	`tb_cloud_event`	Kafka topic for cloud events (entity, attribute, and alarm changes to send to the server)
`queue.cloud-event.poll-interval`	`TB_QUEUE_CLOUD_EVENT_POLL_INTERVAL_MS`	`25`	Poll interval in milliseconds for the cloud event topic
`queue.cloud-event-ts.topic`	`TB_QUEUE_CLOUD_EVENT_TS_TOPIC`	`tb_cloud_event_ts`	Kafka topic for time-series cloud events
`queue.cloud-event-ts.poll-interval`	`TB_QUEUE_CLOUD_EVENT_TS_POLL_INTERVAL_MS`	`25`	Poll interval in milliseconds for the time-series cloud event topic
`queue.kafka.topic-properties.cloud_event`	`TB_QUEUE_KAFKA_CLOUD_EVENT_TOPIC_PROPERTIES`	`retention.ms:2678400000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for the cloud event topic
`queue.kafka.topic-properties.cloud_event_ts`	`TB_QUEUE_KAFKA_CLOUD_EVENT_TS_TOPIC_PROPERTIES`	`retention.ms:2678400000;segment.bytes:52428800;retention.bytes:10485760000;partitions:1;min.insync.replicas:1`	Kafka properties for the time-series cloud event topic
`queue.prefix`	`TB_QUEUE_PREFIX`	`_(empty)_`	Global queue prefix. If specified, prefix is added before default topic name: ‘prefix.default_topic_name’. Prefix is applied to all topics (and consumer groups for kafka).
`queue.in_memory.stats.print-interval-ms`	`TB_QUEUE_IN_MEMORY_STATS_PRINT_INTERVAL_MS`	`60000`	For debug level
`queue.kafka.bootstrap.servers`	`TB_KAFKA_SERVERS`	`localhost:9092`	Kafka Bootstrap nodes in “host:port” format
`queue.kafka.ssl.enabled`	`TB_KAFKA_SSL_ENABLED`	`false`	Enable/Disable SSL Kafka communication
`queue.kafka.ssl.truststore.location`	`TB_KAFKA_SSL_TRUSTSTORE_LOCATION`	`_(empty)_`	The location of the trust store file
`queue.kafka.ssl.truststore.password`	`TB_KAFKA_SSL_TRUSTSTORE_PASSWORD`	`_(empty)_`	The password of trust store file if specified
`queue.kafka.ssl.keystore.location`	`TB_KAFKA_SSL_KEYSTORE_LOCATION`	`_(empty)_`	The location of the key store file. This is optional for the client and can be used for two-way authentication for the client
`queue.kafka.ssl.keystore.password`	`TB_KAFKA_SSL_KEYSTORE_PASSWORD`	`_(empty)_`	The store password for the key store file. This is optional for the client and only needed if ‘ssl.keystore.location’ is configured. Key store password is not supported for PEM format
`queue.kafka.ssl.key.password`	`TB_KAFKA_SSL_KEY_PASSWORD`	`_(empty)_`	The password of the private key in the key store file or the PEM key specified in ‘keystore.key’
`queue.kafka.acks`	`TB_KAFKA_ACKS`	`all`	The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are allowed:0, 1 and all
`queue.kafka.retries`	`TB_KAFKA_RETRIES`	`1`	Number of retries. Resend any record whose send fails with a potentially transient error
`queue.kafka.compression.type`	`TB_KAFKA_COMPRESSION_TYPE`	`none`	none or gzip
`queue.kafka.batch.size`	`TB_KAFKA_BATCH_SIZE`	`16384`	Default batch size. This setting gives the upper bound of the batch size to be sent
`queue.kafka.linger.ms`	`TB_KAFKA_LINGER_MS`	`1`	This variable creates a small amount of artificial delay—that is, rather than immediately sending out a record
`queue.kafka.max.request.size`	`TB_KAFKA_MAX_REQUEST_SIZE`	`1048576`	The maximum size of a request in bytes. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests
`queue.kafka.max.in.flight.requests.per.connection`	`TB_KAFKA_MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION`	`5`	The maximum number of unacknowledged requests the client will send on a single connection before blocking
`queue.kafka.buffer.memory`	`TB_BUFFER_MEMORY`	`33554432`	The total bytes of memory the producer can use to buffer records waiting to be sent to the server
`queue.kafka.replication_factor`	`TB_QUEUE_KAFKA_REPLICATION_FACTOR`	`1`	The multiple copies of data over the multiple brokers of Kafka
`queue.kafka.max_poll_interval_ms`	`TB_QUEUE_KAFKA_MAX_POLL_INTERVAL_MS`	`300000`	The maximum delay between invocations of poll() method when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records
`queue.kafka.max_poll_records`	`TB_QUEUE_KAFKA_MAX_POLL_RECORDS`	`8192`	The maximum number of records returned in a single call of poll() method
`queue.kafka.max_partition_fetch_bytes`	`TB_QUEUE_KAFKA_MAX_PARTITION_FETCH_BYTES`	`16777216`	The maximum amount of data per-partition the server will return. Records are fetched in batches by the consumer
`queue.kafka.fetch_max_bytes`	`TB_QUEUE_KAFKA_FETCH_MAX_BYTES`	`134217728`	The maximum amount of data the server will return. Records are fetched in batches by the consumer
`queue.kafka.request.timeout.ms`	`TB_QUEUE_KAFKA_REQUEST_TIMEOUT_MS`	`30000`	(30 seconds)
`queue.kafka.session.timeout.ms`	`TB_QUEUE_KAFKA_SESSION_TIMEOUT_MS`	`10000`	(10 seconds)
`queue.kafka.auto_offset_reset`	`TB_QUEUE_KAFKA_AUTO_OFFSET_RESET`	`earliest`	earliest, latest or none
`queue.kafka.use_confluent_cloud`	`TB_QUEUE_KAFKA_USE_CONFLUENT_CLOUD`	`false`	Enable/Disable using of Confluent Cloud
`queue.kafka.confluent.ssl.algorithm`	`TB_QUEUE_KAFKA_CONFLUENT_SSL_ALGORITHM`	`https`	The endpoint identification algorithm used by clients to validate server hostname. The default value is https
`queue.kafka.confluent.sasl.mechanism`	`TB_QUEUE_KAFKA_CONFLUENT_SASL_MECHANISM`	`PLAIN`	The mechanism used to authenticate Schema Registry requests. SASL/PLAIN should only be used with TLS/SSL as a transport layer to ensure that clear passwords are not transmitted on the wire without encryption
`queue.kafka.confluent.sasl.config`	`TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG`	`org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";`	Using JAAS Configuration for specifying multiple SASL mechanisms on a broker
`queue.kafka.confluent.security.protocol`	`TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL`	`SASL_SSL`	Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
`queue.kafka.consumer-properties-per-topic.tb_ota_package.key`	`_(none)_`	`max.poll.records`	Key-value properties for Kafka consumer per specific topic, e.g. tb_ota_package is a topic name for ota, tb_rule_engine.sq is a topic name for default SequentialByOriginator queue. Check TB_QUEUE_CORE_OTA_TOPIC and TB_QUEUE_RE_SQ_TOPIC params
`queue.kafka.consumer-properties-per-topic.tb_ota_package.value`	`TB_QUEUE_KAFKA_OTA_MAX_POLL_RECORDS`	`10`	Example of specific consumer properties value per topic
`queue.kafka.consumer-properties-per-topic.tb_version_control.key`	`_(none)_`	`max.poll.interval.ms`	Example of specific consumer properties value per topic for VC
`queue.kafka.consumer-properties-per-topic.tb_version_control.value`	`TB_QUEUE_KAFKA_VC_MAX_POLL_INTERVAL_MS`	`600000`	Example of specific consumer properties value per topic for VC
`queue.kafka.consumer-properties-per-topic.tb_housekeeper.key`	`_(none)_`	`max.poll.records`	Consumer properties for Housekeeper tasks topic
`queue.kafka.consumer-properties-per-topic.tb_housekeeper.value`	`TB_QUEUE_KAFKA_HOUSEKEEPER_MAX_POLL_RECORDS`	`1`	Amount of records to be returned in a single poll. For Housekeeper tasks topic, we should consume messages (tasks) one by one
`queue.kafka.consumer-properties-per-topic.tb_housekeeper.reprocessing.key`	`_(none)_`	`max.poll.records`	Consumer properties for Housekeeper reprocessing topic
`queue.kafka.consumer-properties-per-topic.tb_housekeeper.reprocessing.value`	`TB_QUEUE_KAFKA_HOUSEKEEPER_REPROCESSING_MAX_POLL_RECORDS`	`1`	Amount of records to be returned in a single poll. For Housekeeper reprocessing topic, we should consume messages (tasks) one by one
`queue.kafka.other-inline`	`TB_QUEUE_KAFKA_OTHER_PROPERTIES`	`_(empty)_`	In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin
`queue.kafka.topic-properties.rule-engine`	`TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Rule Engine
`queue.kafka.topic-properties.core`	`TB_QUEUE_KAFKA_CORE_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Core topics
`queue.kafka.topic-properties.transport-api`	`TB_QUEUE_KAFKA_TA_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:10;min.insync.replicas:1`	Kafka properties for Transport Api topics
`queue.kafka.topic-properties.notifications`	`TB_QUEUE_KAFKA_NOTIFICATIONS_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Notifications topics
`queue.kafka.topic-properties.js-executor`	`TB_QUEUE_KAFKA_JE_TOPIC_PROPERTIES`	`retention.ms:86400000;segment.bytes:52428800;retention.bytes:104857600;partitions:30;min.insync.replicas:1`	Kafka properties for JS Executor topics
`queue.kafka.topic-properties.ota-updates`	`TB_QUEUE_KAFKA_OTA_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:10;min.insync.replicas:1`	Kafka properties for OTA updates topic
`queue.kafka.topic-properties.version-control`	`TB_QUEUE_KAFKA_VC_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Version Control topic
`queue.kafka.topic-properties.housekeeper`	`TB_QUEUE_KAFKA_HOUSEKEEPER_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:10;min.insync.replicas:1`	Kafka properties for Housekeeper tasks topic
`queue.kafka.topic-properties.housekeeper-reprocessing`	`TB_QUEUE_KAFKA_HOUSEKEEPER_REPROCESSING_TOPIC_PROPERTIES`	`retention.ms:7776000000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Housekeeper reprocessing topic; retention.ms is set to 90 days; partitions is set to 1 since only one reprocessing service is running at a time
`queue.kafka.topic-properties.edge`	`TB_QUEUE_KAFKA_EDGE_TOPIC_PROPERTIES`	`retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000;partitions:1;min.insync.replicas:1`	Kafka properties for Edge topic
`queue.kafka.consumer-stats.enabled`	`TB_QUEUE_KAFKA_CONSUMER_STATS_ENABLED`	`true`	Prints lag between consumer group offset and last messages offset in Kafka topics
`queue.kafka.consumer-stats.print-interval-ms`	`TB_QUEUE_KAFKA_CONSUMER_STATS_MIN_PRINT_INTERVAL_MS`	`60000`	Statistics printing interval for Kafka’s consumer-groups stats
`queue.kafka.consumer-stats.kafka-response-timeout-ms`	`TB_QUEUE_KAFKA_CONSUMER_STATS_RESPONSE_TIMEOUT_MS`	`1000`	Time to wait for the stats-loading requests to Kafka to finish
`queue.partitions.hash_function_name`	`TB_QUEUE_PARTITIONS_HASH_FUNCTION_NAME`	`murmur3_128`	murmur3_32, murmur3_128 or sha256
`queue.transport_api.requests_topic`	`TB_QUEUE_TRANSPORT_API_REQUEST_TOPIC`	`tb_transport.api.requests`	Topic used to consume api requests from transport microservices
`queue.transport_api.responses_topic`	`TB_QUEUE_TRANSPORT_API_RESPONSE_TOPIC`	`tb_transport.api.responses`	Topic used to produce api responses to transport microservices
`queue.transport_api.max_pending_requests`	`TB_QUEUE_TRANSPORT_MAX_PENDING_REQUESTS`	`10000`	Maximum pending api requests from transport microservices to be handled by server
`queue.transport_api.max_requests_timeout`	`TB_QUEUE_TRANSPORT_MAX_REQUEST_TIMEOUT`	`10000`	Maximum timeout in milliseconds to handle api request from transport microservice by server
`queue.transport_api.max_callback_threads`	`TB_QUEUE_TRANSPORT_MAX_CALLBACK_THREADS`	`100`	Amount of threads used to invoke callbacks
`queue.transport_api.max_core_handler_threads`	`TB_QUEUE_TRANSPORT_MAX_CORE_HANDLER_THREADS`	`16`	Amount of threads used for transport API requests
`queue.transport_api.request_poll_interval`	`TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS`	`25`	Interval in milliseconds to poll api requests from transport microservices
`queue.transport_api.response_poll_interval`	`TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS`	`25`	Interval in milliseconds to poll api response from transport microservices
`queue.core.topic`	`TB_QUEUE_CORE_TOPIC`	`tb_core`	Default topic name of Kafka, RabbitMQ, etc. queue
`queue.core.poll-interval`	`TB_QUEUE_CORE_POLL_INTERVAL_MS`	`25`	Interval in milliseconds to poll messages by Core microservices
`queue.core.partitions`	`TB_QUEUE_CORE_PARTITIONS`	`10`	Amount of partitions used by Core microservices
`queue.core.pack-processing-timeout`	`TB_QUEUE_CORE_PACK_PROCESSING_TIMEOUT_MS`	`2000`	Timeout for processing a message pack by Core microservices
`queue.core.consumer-per-partition`	`TB_QUEUE_CORE_CONSUMER_PER_PARTITION`	`true`	Enable/disable a separate consumer per partition for Core queue
`queue.core.ota.topic`	`TB_QUEUE_CORE_OTA_TOPIC`	`tb_ota_package`	Default topic name for OTA updates
`queue.core.ota.pack-interval-ms`	`TB_QUEUE_CORE_OTA_PACK_INTERVAL_MS`	`60000`	The interval of processing the OTA updates for devices. Used to avoid any harm to the network due to many parallel OTA updates
`queue.core.ota.pack-size`	`TB_QUEUE_CORE_OTA_PACK_SIZE`	`100`	The size of OTA updates notifications fetched from the queue. The queue stores pairs of firmware and device ids
`queue.core.usage-stats-topic`	`TB_QUEUE_US_TOPIC`	`tb_usage_stats`	Stats topic name for queue Kafka, RabbitMQ, etc.
`queue.core.stats.enabled`	`TB_QUEUE_CORE_STATS_ENABLED`	`true`	Enable/disable statistics for Core microservices
`queue.core.stats.print-interval-ms`	`TB_QUEUE_CORE_STATS_PRINT_INTERVAL_MS`	`60000`	Statistics printing interval for Core microservices
`queue.core.housekeeper.topic`	`TB_HOUSEKEEPER_TOPIC`	`tb_housekeeper`	Topic name for Housekeeper tasks
`queue.core.housekeeper.reprocessing-topic`	`TB_HOUSEKEEPER_REPROCESSING_TOPIC`	`tb_housekeeper.reprocessing`	Topic name for Housekeeper tasks to be reprocessed
`queue.core.housekeeper.poll-interval-ms`	`TB_HOUSEKEEPER_POLL_INTERVAL_MS`	`500`	Poll interval for topics related to Housekeeper
`queue.core.housekeeper.task-processing-timeout-ms`	`TB_HOUSEKEEPER_TASK_PROCESSING_TIMEOUT_MS`	`120000`	Timeout in milliseconds for task processing. Tasks that fail to finish on time will be submitted for reprocessing
`queue.core.housekeeper.disabled-task-types`	`TB_HOUSEKEEPER_DISABLED_TASK_TYPES`	`_(empty)_`	Comma-separated list of task types that shouldn’t be processed. Available task types: DELETE_ATTRIBUTES, DELETE_TELEMETRY (both DELETE_LATEST_TS and DELETE_TS_HISTORY will be disabled), DELETE_LATEST_TS, DELETE_TS_HISTORY, DELETE_EVENTS, DELETE_ALARMS, UNASSIGN_ALARMS
`queue.core.housekeeper.task-reprocessing-delay-ms`	`TB_HOUSEKEEPER_TASK_REPROCESSING_DELAY_MS`	`3000`	Delay in milliseconds between tasks reprocessing
`queue.core.housekeeper.max-reprocessing-attempts`	`TB_HOUSEKEEPER_MAX_REPROCESSING_ATTEMPTS`	`10`	Maximum amount of task reprocessing attempts. After exceeding, the task will be dropped
`queue.core.housekeeper.stats.enabled`	`TB_HOUSEKEEPER_STATS_ENABLED`	`true`	Enable/disable statistics for Housekeeper
`queue.core.housekeeper.stats.print-interval-ms`	`TB_HOUSEKEEPER_STATS_PRINT_INTERVAL_MS`	`60000`	Statistics printing interval for Housekeeper
`queue.vc.topic`	`TB_QUEUE_VC_TOPIC`	`tb_version_control`	Default topic name for Kafka, RabbitMQ, etc.
`queue.vc.partitions`	`TB_QUEUE_VC_PARTITIONS`	`10`	Number of partitions to associate with this queue. Used for scaling the number of messages that can be processed in parallel
`queue.vc.poll-interval`	`TB_QUEUE_VC_INTERVAL_MS`	`25`	Interval in milliseconds between polling of the messages if no new messages arrive
`queue.vc.pack-processing-timeout`	`TB_QUEUE_VC_PACK_PROCESSING_TIMEOUT_MS`	`180000`	Timeout before retrying all failed and timed-out messages from the processing pack
`queue.vc.request-timeout`	`TB_QUEUE_VC_REQUEST_TIMEOUT`	`180000`	Timeout for a request to VC-executor (for a request for the version of the entity, for a commit charge, etc.)
`queue.vc.msg-chunk-size`	`TB_QUEUE_VC_MSG_CHUNK_SIZE`	`250000`	Queue settings for Kafka, RabbitMQ, etc. Limit for single message size
`queue.js.request_topic`	`REMOTE_JS_EVAL_REQUEST_TOPIC`	`js_eval.requests`	JS Eval request topic
`queue.js.response_topic_prefix`	`REMOTE_JS_EVAL_RESPONSE_TOPIC`	`js_eval.responses`	JS Eval responses topic prefix that is combined with node id
`queue.js.max_pending_requests`	`REMOTE_JS_MAX_PENDING_REQUESTS`	`10000`	JS Eval max pending requests
`queue.js.max_eval_requests_timeout`	`REMOTE_JS_MAX_EVAL_REQUEST_TIMEOUT`	`60000`	JS Eval max request timeout
`queue.js.max_requests_timeout`	`REMOTE_JS_MAX_REQUEST_TIMEOUT`	`10000`	JS max request timeout
`queue.js.max_exec_requests_timeout`	`REMOTE_JS_MAX_EXEC_REQUEST_TIMEOUT`	`2000`	JS execution max request timeout
`queue.js.response_poll_interval`	`REMOTE_JS_RESPONSE_POLL_INTERVAL_MS`	`25`	JS response poll interval
`queue.rule-engine.topic`	`TB_QUEUE_RULE_ENGINE_TOPIC`	`tb_rule_engine`	Deprecated. It will be removed in the nearest releases
`queue.rule-engine.poll-interval`	`TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS`	`25`	Interval in milliseconds to poll messages by Rule Engine
`queue.rule-engine.pack-processing-timeout`	`TB_QUEUE_RULE_ENGINE_PACK_PROCESSING_TIMEOUT_MS`	`2000`	Timeout for processing a message pack of Rule Engine
`queue.rule-engine.stats.enabled`	`TB_QUEUE_RULE_ENGINE_STATS_ENABLED`	`true`	Enable/disable statistics for Rule Engine
`queue.rule-engine.stats.print-interval-ms`	`TB_QUEUE_RULE_ENGINE_STATS_PRINT_INTERVAL_MS`	`60000`	Statistics printing interval for Rule Engine
`queue.rule-engine.stats.max-error-message-length`	`TB_QUEUE_RULE_ENGINE_MAX_ERROR_MESSAGE_LENGTH`	`4096`	Max length of the error message that is printed by statistics
`queue.rule-engine.topic-deletion-delay`	`TB_QUEUE_RULE_ENGINE_TOPIC_DELETION_DELAY_SEC`	`15`	After a queue is deleted (or the profile’s isolation option was disabled), Rule Engine will continue reading related topics during this period before deleting the actual topics
`queue.rule-engine.management-thread-pool-size`	`TB_QUEUE_RULE_ENGINE_MGMT_THREAD_POOL_SIZE`	`12`	Size of the thread pool that handles such operations as partition changes, config updates, queue deletion
`queue.transport.notifications_topic`	`TB_QUEUE_TRANSPORT_NOTIFICATIONS_TOPIC`	`tb_transport.notifications`	For high-priority notifications that require minimum latency and processing time
`queue.transport.poll_interval`	`TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS`	`25`	Interval in milliseconds to poll messages
`queue.edge.topic`	`TB_QUEUE_EDGE_TOPIC`	`tb_edge`	Default topic name for Kafka, RabbitMQ, etc.
`queue.edge.partitions`	`TB_QUEUE_EDGE_PARTITIONS`	`10`	Amount of partitions used by Edge services
`queue.edge.poll-interval`	`TB_QUEUE_EDGE_POLL_INTERVAL_MS`	`25`	Poll interval for topics related to Edge services
`queue.edge.pack-processing-timeout`	`TB_QUEUE_EDGE_PACK_PROCESSING_TIMEOUT_MS`	`10000`	Timeout for processing a message pack by Edge services
`queue.edge.pack-processing-retries`	`TB_QUEUE_EDGE_MESSAGE_PROCESSING_RETRIES`	`3`	Retries for processing a failure message pack by Edge services
`queue.edge.consumer-per-partition`	`TB_QUEUE_EDGE_CONSUMER_PER_PARTITION`	`false`	Enable/disable a separate consumer per partition for Edge queue
`queue.edge.stats.enabled`	`TB_QUEUE_EDGE_STATS_ENABLED`	`true`	Enable/disable statistics for Edge services
`queue.edge.stats.print-interval-ms`	`TB_QUEUE_EDGE_STATS_PRINT_INTERVAL_MS`	`60000`	Statistics printing interval for Edge services

Event configuration parameters

Parameter	Env variable	Default	Description
`event.debug.max-symbols`	`TB_MAX_DEBUG_EVENT_SYMBOLS`	`4096`	Maximum number of symbols per debug event. The event content will be truncated if needed

General service parameters

Parameter	Env variable	Default	Description
`service.type`	`TB_SERVICE_TYPE`	`monolith`	monolith or tb-core or tb-rule-engine
`service.id`	`TB_SERVICE_ID`	`_(empty)_`	Unique id for this service (autogenerated if empty)
`service.rule_engine.assigned_tenant_profiles`	`TB_RULE_ENGINE_ASSIGNED_TENANT_PROFILES`	`_(empty)_`	Comma-separated list of tenant profile ids assigned to this Rule Engine. This Rule Engine will only be responsible for tenants with these profiles (in case ‘isolation’ option is enabled in the profile).
`service.rule_engine.pubsub.executor_thread_pool_size`	`TB_RULE_ENGINE_PUBSUB_EXECUTOR_THREAD_POOL_SIZE`	`0`	Thread pool size for pubsub rule node executor provider. If not set - default pubsub executor provider value will be used (5 * number of available processors)

Tbel parameters

Parameter	Env variable	Default	Description
`tbel.enabled`	`TBEL_ENABLED`	`true`	Enable/Disable TBEL feature.
`tbel.max_total_args_size`	`TBEL_MAX_TOTAL_ARGS_SIZE`	`100000`	Limit the number of arguments that are passed to the function to execute the script
`tbel.max_result_size`	`TBEL_MAX_RESULT_SIZE`	`300000`	Maximum allowed symbols in a result after processing a script
`tbel.max_script_body_size`	`TBEL_MAX_SCRIPT_BODY_SIZE`	`50000`	Maximum allowed symbols in the script body
`tbel.max_memory_limit_mb`	`TBEL_MAX_MEMORY_LIMIT_MB`	`8`	Maximum allowed TBEL script execution memory
`tbel.max_errors`	`TBEL_MAX_ERRORS`	`3`	Maximum allowed TBEL script execution errors before it will be blacklisted
`tbel.max_requests_timeout`	`TBEL_MAX_REQUEST_TIMEOUT`	`500`	TBEL Eval max request timeout in milliseconds. 0 - no timeout
`tbel.max_black_list_duration_sec`	`TBEL_MAX_BLACKLIST_DURATION_SEC`	`60`	Maximum time in seconds for black listed function to stay in the list.
`tbel.thread_pool_size`	`TBEL_THREAD_POOL_SIZE`	`50`	Specify thread pool size for javascript executor service
`tbel.compiled_scripts_cache_size`	`TBEL_COMPILED_SCRIPTS_CACHE_SIZE`	`1000`	Maximum cache size of TBEL compiled scripts
`tbel.stats.enabled`	`TB_TBEL_STATS_ENABLED`	`false`	Enable/Disable stats collection for TBEL engine
`tbel.stats.print_interval_ms`	`TB_TBEL_STATS_PRINT_INTERVAL_MS`	`10000`	Interval of logging for TBEL stats

JS parameters

Parameter	Env variable	Default	Description
`js.evaluator`	`JS_EVALUATOR`	`local`	local (Nashorn Engine, deprecated) OR remote JS-Executors (NodeJS)
`js.max_total_args_size`	`JS_MAX_TOTAL_ARGS_SIZE`	`150000`	Limit the number of arguments that are passed to the function to execute the script
`js.max_result_size`	`JS_MAX_RESULT_SIZE`	`300000`	Maximum allowed symbols in a result after processing a script
`js.max_script_body_size`	`JS_MAX_SCRIPT_BODY_SIZE`	`50000`	Maximum allowed symbols in script body
`js.local.js_thread_pool_size`	`LOCAL_JS_THREAD_POOL_SIZE`	`50`	Specify thread pool size for javascript executor service
`js.local.use_js_sandbox`	`USE_LOCAL_JS_SANDBOX`	`true`	Use Sandboxed (secured) JVM JavaScript environment
`js.local.monitor_thread_pool_size`	`LOCAL_JS_SANDBOX_MONITOR_THREAD_POOL_SIZE`	`4`	Specify thread pool size for JavaScript sandbox resource monitor
`js.local.max_cpu_time`	`LOCAL_JS_SANDBOX_MAX_CPU_TIME`	`8000`	Maximum CPU time in milliseconds allowed for script execution
`js.local.max_memory`	`LOCAL_JS_SANDBOX_MAX_MEMORY`	`104857600`	Maximum memory in Bytes which JS executor thread can allocate (approximate calculation). A zero memory limit in combination with a non-zero CPU limit is not recommended due to the implementation of Nashorn 0.4.2. 100MiB is effectively unlimited for most cases
`js.local.max_errors`	`LOCAL_JS_SANDBOX_MAX_ERRORS`	`3`	Maximum allowed JavaScript execution errors before JavaScript will be blacklisted
`js.local.max_requests_timeout`	`LOCAL_JS_MAX_REQUEST_TIMEOUT`	`0`	JS Eval max request timeout. 0 - no timeout
`js.local.max_black_list_duration_sec`	`LOCAL_JS_SANDBOX_MAX_BLACKLIST_DURATION_SEC`	`60`	Maximum time in seconds for black listed function to stay in the list.
`js.local.stats.enabled`	`TB_JS_LOCAL_STATS_ENABLED`	`false`	Enable/Disable stats collection for local JS executor
`js.local.stats.print_interval_ms`	`TB_JS_LOCAL_STATS_PRINT_INTERVAL_MS`	`10000`	Interval of logging for local JS executor stats
`js.remote.js_thread_pool_size`	`REMOTE_JS_THREAD_POOL_SIZE`	`50`	Specify thread pool size for javascript executor service
`js.remote.max_errors`	`REMOTE_JS_SANDBOX_MAX_ERRORS`	`3`	Maximum allowed JavaScript execution errors before JavaScript will be blacklisted
`js.remote.max_black_list_duration_sec`	`REMOTE_JS_SANDBOX_MAX_BLACKLIST_DURATION_SEC`	`60`	Maximum time in seconds for black listed function to stay in the list.
`js.remote.stats.enabled`	`TB_JS_REMOTE_STATS_ENABLED`	`false`	Enable/Disable stats collection for remote JS executor
`js.remote.stats.print_interval_ms`	`TB_JS_REMOTE_STATS_PRINT_INTERVAL_MS`	`10000`	Interval of logging for remote JS executor stats

Device state parameters

Parameter	Env variable	Default	Description
`state.defaultInactivityTimeoutInSec`	`DEFAULT_INACTIVITY_TIMEOUT`	`600`	Device inactivity timeout is a global configuration parameter that defines when the device will be marked as “inactive” by the server. The parameter value is in seconds. A user can overwrite this parameter for an individual device by setting the “inactivityTimeout” server-side attribute (NOTE: expects value in milliseconds). We recommend this parameter to be in sync with session inactivity timeout (“transport.sessions.inactivity_timeout” or TB_TRANSPORT_SESSIONS_INACTIVITY_TIMEOUT) parameter which is responsible for detection of the stale device connection sessions. The value of the session inactivity timeout parameter should be greater or equal to the device inactivity timeout. Note that the session inactivity timeout is set in milliseconds while device inactivity timeout is in seconds.
`state.defaultStateCheckIntervalInSec`	`DEFAULT_STATE_CHECK_INTERVAL`	`60`	Interval for checking the device state after a specified period. Time in seconds
`state.persistToTelemetry`	`PERSIST_STATE_TO_TELEMETRY`	`false`	Controls whether we store the device ‘active’ flag in attributes (default) or telemetry. If you decide to change this parameter, you should re-create the device info view as one of the following: If ‘persistToTelemetry’ is changed from ‘false’ to ‘true’: ‘CREATE OR REPLACE VIEW device_info_view AS SELECT * FROM device_info_active_ts_view;’ If ‘persistToTelemetry’ is changed from ‘true’ to ‘false’: ‘CREATE OR REPLACE VIEW device_info_view AS SELECT * FROM device_info_active_attribute_view;’
`state.telemetryTtl`	`STATE_TELEMETRY_TTL`	`0`	Millisecond value defining time-to-live for device state telemetry data (e.g. ‘active’, ‘lastActivityTime’). Used only when state.persistToTelemetry is set to ‘true’ and Cassandra is used for timeseries data. 0 means time-to-live mechanism is disabled.
`state.rule.node.deviceState.rateLimit`	`DEVICE_STATE_NODE_RATE_LIMIT_CONFIGURATION`	`1:1,30:60,60:3600`	Defines the rate at which device connectivity events can be triggered. Comma-separated list of capacity:duration pairs that define bandwidth capacity and refill duration for token bucket rate limit algorithm. Refill is set to be greedy. Please refer to Bucket4j library documentation for more details.

Version control parameters

Parameter	Env variable	Default	Description
`vc.thread_pool_size`	`TB_VC_POOL_SIZE`	`6`	Pool size for handling export tasks
`vc.git.io_pool_size`	`TB_VC_GIT_POOL_SIZE`	`3`	Pool size for handling the git IO operations
`vc.git.repositories-folder`	`TB_VC_GIT_REPOSITORIES_FOLDER`	`${java.io.tmpdir}/repositories`	Default storing repository path

Update version parameters

Parameter	Env variable	Default	Description
`updates.enabled`	`UPDATES_ENABLED`	`true`	Enable/disable checks for the new version

Was this helpful?