System Monitoring

Overview

PlantPulse monitoring consists of 3 layers. Using the tools in each layer together allows you to detect issues early and respond quickly.

Layer	Responsibility	Frequency
L1 Host/Stack	Container state, health, resource usage, health response	Every minute–5 minutes (auto/manual)
L2 Platform Built-in	Module-level business metrics (throughput, lag, queue depth, JVM)	Real-time
L3 External Monitoring	Long-term trends, alarms, multi-host integrated view	Real-time

Platform Service Modules

PlantPulse comprises multiple service modules starting with the plantpulse- prefix. Modules and containers are not 1:1 — six applications each have their own container, while the remaining infrastructure modules share a single plantpulse-datalake container.

Location	Module
Own container	plantpulse-server-web · plantpulse-batch-web · plantpulse-warehouse · plantpulse-plugin-opcua-server · plantpulse-plugin-aasx-server · plantpulse-ha
Inside plantpulse-datalake container	storage · messaging · analytics · timeseries · workflow · cep · data-gateway · sql · monitor · backup

Container-level status is viewed from the host with bin/status.sh, and module-level status within the data lake is viewed with status.sh. The «ports» below are those opened inside the container by that module; only some are exposed to the host → Port Configuration

Core Service Modules

Module	Port	Description
plantpulse-server	80 / 443 / 7443	Web server and management console, REST API
plantpulse-cep	7400 / 7401	Complex Event Processing Engine (Esper)
plantpulse-batch	9500	Batch processing server
plantpulse-data-gateway	5500	Data gateway (HTTP REST-based data query)
plantpulse-sql	4000	SQL query tool
plantpulse-monitor	4950 (HTTPS)	System monitoring agent. The only health port published to the host
plantpulse-warehouse	9600	Data warehouse
plantpulse-plugin-opcua-server	11004 / 11005	OPC-UA server plugin
plantpulse-plugin-aasx-server	(not exposed to host)	AASX server plugin
plantpulse-ha	10210	Redundancy recovery daemon
plantpulse-proxy	80 / 443 / 1883 / 1884	The only entry point for users and equipment

Messaging Module (plantpulse-messaging)

Service	Port	Description
Kafka	9092	Distributed message streaming
MQTT	1883	IoT lightweight message protocol
MQTT Enterprise	-	MQTT Enterprise Edition

Storage Module (plantpulse-storage)

Service	Port	Description
Cassandra 6.0	9042	Time series database (CQL)
PostgreSQL	5432	Metadata relational database
Valkey (Redis)	6379	In-memory cache
MinIO	9000	Object storage (S3 compatible)
JanusGraph	-	Graph database
RustFS / WeedFS	-	Distributed file system

Analytics Module (plantpulse-analytics)

Service	Port	Description
Spark Master	7077	Distributed analytics engine
Spark UI	4440	Spark management console
Kyuubi	10000	Distributed SQL gateway (JDBC/Thrift)
Gravitino	19001	Data catalog
Hadoop	-	Distributed file system
Hive	-	Data warehouse query engine

Timeseries Module (plantpulse-timeseries)

Service	Port	Description
Timeseries Engine	7800	Timeseries data processing engine
Timeseries UI	3000	Timeseries data visualization UI

Workflow Module (plantpulse-workflow)

Service	Port	Description
Temporal	7233	Distributed workflow engine (Web UI 8233)
Kestra	8380	Workflow orchestration / scheduler

Utility Modules

Module	Description
plantpulse-datalake-cli (pd)	Data lake start/stop/restart, configuration, node management CLI
plantpulse-setup	Initial setup tool (models, CSV configuration)
plantpulse-backup	Backup service
plantpulse-recovery	Data recovery tool
plantpulse-exporter	Asset data export tool
plantpulse-migrator	Data migration tool (Spark-based)
plantpulse-mirror-maker	Data replication tool
plantpulse-simulator	Data simulator (for testing)
plantpulse-api	REST API client library

Checking Service Status

From the host check the status of the entire stack first.

cd /opt/kopens/plantpulse-platform-docker/bin
./status.sh          # 0 = 정상 / 2 = 비정상
./ops-check.sh       # 헬스 + 최근 critical log

For port-level status of infrastructure modules inside the data lake container:

./shell.sh
/opt/kopens/plantpulse-platform/plantpulse-datalake-cli/bin/pd status

Example output:

==============================================================================================================
 PLANTPULSE PLATFORM - ALL SERVICE STATUS
 2026-03-01 12:00:00
==============================================================================================================

<SYSTEM RESOURCE OVERVIEW>
--------------------------------------------------------------------------------------------------------------
 포트   서비스                     상태
--------------------------------------------------------------------------------------------------------------
 9092   PP_MESSAGING[KAFKA]        ● RUNNING
 1883   PP_MESSAGING[MQTT]         ● RUNNING
 9042   PP_STORAGE[CASSANDRA]      ● RUNNING
 5432   PP_STORAGE[POSTGRESQL]     ● RUNNING
 6379   PP_STORAGE[REDIS]          ● RUNNING
 9000   PP_STORAGE[MINIO]          ● RUNNING
 7077   PP_ANALYTICS[SPARK-MASTER] ● RUNNING
 4440   PP_ANALYTICS[SPARK-UI]     ● RUNNING
 10000  PP_ANALYTICS[KYUUBI]       ● RUNNING
 19001  PP_ANALYTICS[GRAVITINO]    ● RUNNING
 7233   PP_WORKFLOW[ENGINE]        ● RUNNING
 8380   PP_WORKFLOW[BATCH]         ● RUNNING
 7800   PP_TIMESERIES[ENGINE]      ● RUNNING
 3000   PP_TIMESERIES[UI]          ● RUNNING
 7400   PP_CEP                     ● RUNNING
 5500   PP_DATA_GATEWAY            ● RUNNING
 4000   PP_SQL                     ● RUNNING
 4950   PP_MONITOR                 ● RUNNING
 60000  PP_AGENT                   ● RUNNING
 80     PP_SERVER                  ● RUNNING
 9500   PP_BATCH                   ● RUNNING
 9600   PP_WAREHOUSE               ● RUNNING
 11004  PP_PLUGIN[OPCUA]           ● RUNNING

App containers do not appear in the list above

The status.sh inside the data lake only checks modules in that container. If PP_SERVER · PP_BATCH · PP_WAREHOUSE · PP_PLUGIN items show STOPPED or are missing, it is not a failure — those apps run in their own containers, and the determination is made by bin/status.sh on the host.

Environment Variables

Host-side values are set by /opt/kopens/plantpulse-platform-docker/bin/env.sh, while the values actually seen by the container are determined by compose/docker-compose.yml. The detailed relationship and priority are in Environment Variable Reference. The names below are used inside the container.

Variable	Description	Example
PP_SCHEME	Schema name	PP
PP_MODE	Execution mode	MASTER
PP_HOST_IP	Internal IP	192.168.0.41
PP_SERVICE_IP	Service IP	192.168.0.41
PP_MASTER_IP	Master node IP	192.168.0.41
PP_DATA_DIR	Data directory	/data1/pp-data
PP_TEMP_DIR	Temporary directory	/data1/pp-temp
PP_BACKUP_DIR	Backup directory	/data1/pp-backup
PP_CLUSTER_CORES	Cluster CPU cores	16
PP_CLUSTER_MEMORY_BY_CORE	Memory per core	2G
PP_OPTIONS	Additional options (JSON)	{"use-infra":true,"use-app":true}

Monitoring Targets

Key targets and items to monitor in the PlantPulse platform are as follows. Regular checks of each item will help ensure stable operation.

Target	Monitoring Items
Application server	CPU, memory, disk, threads
JVM	Heap memory, GC, class loading
PostgreSQL	Connection pool, query performance, disk
Cassandra	Cluster status, latency, compaction
Redis	Memory, hit rate, connections
Engine	Pipeline throughput, queue depth, error rate
Network	OPC connections, WebSocket, latency

Web Console Monitoring

System Monitoring Screen

Path: /monitoring/index

Displays real-time system status in dashboard form. If any metric falls outside the "normal range" in the table below, it may cause performance degradation, so please check.

Metric	Description	Normal Range
CPU Usage	Server CPU load	< 70%
JVM Heap Memory	Heap used / max	< 80%
Active Threads	Number of running threads	< 500
MPS (Messages/sec)	Messages processed per second	Below configured rate limit
Pipeline Queue	Number of waiting messages	< 10,000
DB Connections	Number of active DB connections	< pool maximum

Server Status

Path: /server/status

Item	Description
Server Uptime	Uptime
Engine Status	RUNNING / STOPPED / ERROR
Last Start Time	Engine last start timestamp
Version Information	Platform version

Log Monitoring

Logs are text files that record system operation state. When a problem occurs, examining logs greatly helps identify the cause.

From the Host — logs.sh

Since there are eight containers, when you don't know which container has an issue, starting without arguments is fastest.

cd /opt/kopens/plantpulse-platform-docker/bin

./logs.sh                              # 여덟 컨테이너를 시간순으로 한 화면에 (서비스 이름 접두)
./logs.sh plantpulse-server-web -n 200 # 웹 서버 컨테이너
./logs.sh cassandra                    # 데이터레이크 안 컴포넌트 로그 파일
./logs.sh --list                       # 볼 수 있는 대상 전체 (그 시점의 실제 목록)
./logs.sh -f plantpulse-server-web     # 계속 따라가기 (Ctrl-C 로 종료)

By default, it prints the last N lines (default 200) and exits. To follow along, add -f.

Log Files Inside the Container

# 웹 서버 — 자기 컨테이너 안에 있습니다
./shell.sh plantpulse-server-web
tail -f /opt/kopens/plantpulse-platform/plantpulse-server/logs/system.log
grep -i "ERROR\|EXCEPTION" /opt/kopens/plantpulse-platform/plantpulse-server/logs/system.log | tail -100

# 인프라 — 데이터레이크 컨테이너 안
./shell.sh
tail -f /opt/kopens/plantpulse-platform/plantpulse-storage/db/cassandra/logs/system.log

To copy logs to the host at once, use ./tools/copy-log-to-local.sh; for support request bundles, use ./doctor.sh.

Log Levels

Level	Description
INFO	Normal operation information
WARN	Warning message (performance degradation, retry situations, etc.)
ERROR	Error occurred (processing failure, connection error, etc.)

Key Log Patterns

If the following log pattern appears, take the corresponding action:

Pattern	Meaning
Engine started successfully	Engine started normally
Pipeline queue overflow	Pipeline queue exceeded — check processing speed
Cassandra connection failed	Cassandra connection failed — check cluster status
OPC connection lost	OPC server connection lost — check network and OPC server
Rate limit exceeded	Processing rate exceeded — adjust engine.pipeline.ratelimit value

Database Monitoring

Regular monitoring of database status helps prevent performance degradation and failures beforehand.

PostgreSQL

# 활성 연결 확인
psql -h HOST -U plantpulse -d pp -c "
SELECT count(*) as active_connections
FROM pg_stat_activity
WHERE state = 'active';"

# 느린 쿼리 확인
psql -h HOST -U plantpulse -d pp -c "
SELECT pid, now() - pg_stat_activity.query_start AS duration, query
FROM pg_stat_activity
WHERE state != 'idle' AND now() - pg_stat_activity.query_start > interval '5 seconds'
ORDER BY duration DESC;"

# 테이블 크기 확인
psql -h HOST -U plantpulse -d pp -c "
SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC
LIMIT 10;"

Cassandra

# 클러스터 상태
nodetool status

# 테이블별 통계
nodetool tablestats pp

# 컴팩션 상태
nodetool compactionstats

# GC 로그 확인
nodetool gcstats

# 지연 히스토그램
nodetool tablehistograms pp tm_tag_point

Cassandra Status Codes:

Status	Description
UN	Up / Normal — healthy state
DN	Down / Normal — node is down
UJ	Up / Joining — joining the cluster
UL	Up / Leaving — leaving the cluster

Redis

# Redis 상태 확인
redis-cli -a 설치-시-변경 INFO

# 메모리 사용량
redis-cli -a 설치-시-변경 INFO memory

# 키 수 확인
redis-cli -a 설치-시-변경 DBSIZE

# 슬로우 로그
redis-cli -a 설치-시-변경 SLOWLOG GET 10

JMX Monitoring

Note: JMX (Java Management Extensions) is a technology that allows monitoring the internal state of Java applications from outside. PlantPulse provides over 150 attributes via JMX.

JMX Connection

# JMX 포트 활성화 (setenv.sh에 추가)
export JAVA_OPTS="$JAVA_OPTS \
  -Dcom.sun.management.jmxremote \
  -Dcom.sun.management.jmxremote.port=9090 \
  -Dcom.sun.management.jmxremote.ssl=false \
  -Dcom.sun.management.jmxremote.authenticate=false"

JMX MBean

• ObjectName: plantpulse:name=MBean
• Categories: engine, cache, storage, network, pipeline, cep, scheduler, monitoring, and 12 others

Key JMX Attributes

Attribute	Description
engine.status	Engine status
engine.uptime	Uptime
pipeline.queue.size	Pipeline queue size
pipeline.mps	Messages processed per second
cache.tag.count	Number of cached tags
storage.cassandra.status	Cassandra connection status

Codahale Metrics

Note: Codahale Metrics is a library for collecting application performance metrics. PlantPulse collects over 70 metrics, which can be queried at the /admin/tool/metrics path.

Metric Types

Type	Description
Counter	Cumulative counter (event count, error count, etc.)
Timer	Measures processing time (average, p95, p99)
Histogram	Shows value distribution (queue depth, batch size)
Gauge	Shows current value (active connections, memory)

Standard Health Check API

Web apps / plugin services provide a health check endpoint GET /api/health following the platform common spec. For major web apps (server / batch / cep / sql / data-gateway), this endpoint is readiness-semantic — it does not report UP just because the process (context) is alive; instead it returns UP only when the internal engine / critical dependencies are healthy and ready to receive traffic (2026-06 platform design decision).

curl -fsS http://127.0.0.1:9500/api/health
# 준비 완료:           200 {"status":"UP","service":"plantpulse-batch-web","ts":1765500000000,"checks":{"timer":true,"redis":true}}
# 기동 진행 중:         503 {"status":"STARTING",...}
# 기동 후 의존성 다운:   503 {"status":"DEGRADED",...,"checks":{...}}

• readiness — 200 UP only when ready. Reports 503 STARTING if still starting, and 503 DEGRADED if some dependencies go down after startup, making the distinction clear.
• No dependency ping — checks only read in-memory state flags that each service already maintains (live DB query / network ping forbidden — polling does not load data stores).
• Anonymous access — can be called without authentication (operational inspection / deployment auto-validation).
• No caching — headers of type Cache-Control: no-cache are always included.
• Response fields are status / service (artifact name) / ts (epoch ms) + checks (detailed checks per service) for readiness-promoted services.

Service	Health URL	Semantic	checks / Notes
server	http://HOST:80/api/health	readiness	engine — engine lifecycle state (UP only when all startup phases complete RUNNING)
batch	http://HOST:9500/api/health	readiness	timer (batch pipeline running) / redis (InMemory connection)
cep	http://HOST:7400/api/health	readiness	engine (CEP engine + consumer + recovery complete) / redis (InMemory connection)
sql	https://HOST:4001/api/health	readiness	database_manager (DB manager initialized) — served via HTTPS
data-gateway	http://HOST:5500/api/health	readiness	database / inmemory / query_log — only this path exempt from HTTPS enforce (CONFIDENTIAL), localhost HTTP probe allowed
warehouse (s3 service)	http://HOST:9600/api/health	readiness	temporal — Temporal worker registration complete. If not registered, STARTING + 503 (web server starts first, workers follow, so 503 right after boot is normal). Includes common 3 fields + system/JVM metrics
plugin — AAS V3	http://HOST:8090/api/health	liveness	readiness not promoted
plugin — OPC-UA Browse UI	http://HOST:12780/api/health	liveness	port is opc.ua.browser.ui.port setting (default 12780)

There are two use cases:

1. Operational inspection — manual checks, crontab / external monitoring readiness probes
2. CI deployment auto-validation — deploy:dev job polls this URL after deployment (DEPLOY_HEALTH, 240 seconds) to confirm startup. Since it is readiness-semantic, 503 during boot is normal; polling waits for UP transition.

Role distinction: plantpulse-monitor (:4950) is the infrastructure monitoring agent that collects and exposes host / JVM / module metrics, while /api/health is the readiness endpoint provided by each web app itself. They are complementary, not interchangeable.

In container environments, each app's readiness is already being judged by compose's healthcheck, so operators get the judgment of all eight containers together with bin/status.sh.

Health Check Script

Using health check scripts allows you to automatically verify that key platform services are operating normally.

Automatic Health Check

Below is an example script that automatically checks the status of key services:

#!/bin/bash
# healthcheck.sh

# 표준 헬스체크 (GET /api/health)
BODY=$(curl -fsS -m 5 http://localhost/api/health 2>/dev/null)
case "$BODY" in
  *'"status":"UP"'*) : ;;  # 정상
  *) echo "[ALERT] PlantPulse server is not responding: ${BODY:-no response}"
     # 알림 발송 로직 추가
     ;;
esac

# PostgreSQL 체크
pg_isready -h HOST -p 5432 -U plantpulse
if [ $? -ne 0 ]; then
    echo "[ALERT] PostgreSQL is not responding"
fi

# Cassandra 체크
nodetool status | grep -q "^UN"
if [ $? -ne 0 ]; then
    echo "[ALERT] Cassandra node is down"
fi

# Redis 체크
redis-cli -a 설치-시-변경 ping | grep -q "PONG"
if [ $? -ne 0 ]; then
    echo "[ALERT] Redis is not responding"
fi

You can register it in crontab for periodic execution:

# 5분마다 헬스체크
*/5 * * * * /opt/scripts/healthcheck.sh >> /var/log/plantpulse-healthcheck.log 2>&1

Grafana Monitoring Dashboard

Platform monitoring is provided visually through Grafana. Access URL: http://localhost:3000/

Note: Grafana is an open-source data visualization tool that displays various PlantPulse metrics as graphs and charts. Five dashboards are provided by default under the PLANTPULSE folder.

---

1. PlantPulse - Server

The core dashboard for understanding the overall status of the platform server at a glance.

SUMMARY

Panel	Type	Description
VERSION	Stat	Platform version information
Server Start Date	Stat	Engine first start timestamp
CPU Load	Gauge	Server CPU usage
Memory Usage	Gauge	Server memory usage
Received per Second	Stat	Messages received per second (MPS)
Total Saved Count	Stat	Accumulated saved data count
Network Latency	Stat	Message receive network latency (ms)
Diagnosis	Stat	Diagnostic event status

SERVER-METRICS

Panel	Type	Description
CACHE / MQTT / KAFKA / WEBSOCKET / DATABASE / TSE	Stat	Connection status of each service
Server CPU Usage	Graph	CPU usage time series trend
Server Memory Usage	Graph	Memory usage time series trend
JAVA Heap Usage	Graph	JVM heap memory usage
Data DISK R/W Status	Graph	Disk read/write traffic
Messages Received by Protocol	Graph	Received volume by protocol (OPC, MQTT, Kafka, etc.)
Message Receive Network Latency	Graph	Network latency time series
Total Message Received	Graph	Cumulative message received count
Message Received Count BY 1SEC	Graph	Messages received per second trend
Pipeline Waiting Queue	Graph	Pipeline queue depth
Pipeline Offload Queue Size	Graph	RocksDB offload queue
Pipeline Validation Failures	Graph	Validation failure count
Pipeline Worker Processing Time	Graph	Worker processing duration
Timeout Message Backup Processing	Graph	Timeout message backup count
Pipeline Collector	Graph	Collector operation status
Storage Save Buffer	Graph	Storage buffer size
Streaming Processing Count	Graph	WebSocket streaming throughput
Streaming Operating Thread Count	Graph	Streaming active threads
Streaming Waiting Queue Count	Graph	Streaming queue wait count
Storage Save Count	Graph	DB save count
Storage Batch Count	Graph	Batch save count
Storage Worker Count	Graph	Storage worker count
DDS Processing Count	Graph	Kafka DDS distribution count
Async Thread Active Count	Graph	Async execution active threads
Async Thread Pool Size	Graph	Thread pool size
Diagnosis Error Count	Graph	Diagnosis error occurrence trend
Logging Exceptions	Graph	Exception log occurrence trend
GC Time	Graph	JVM GC duration
DISK Usage	Graph	Disk usage trend

---

2. PlantPulse - Data Lake House

Dashboard for monitoring the performance and status of the database and storage layers.

DATA-GATEWAY

Panel	Description
TOTAL_QUERY	Total query count
QPS	Queries per second (Gauge)
QUERY_LATENCY	Query latency time series
QUERY_LATENCY_MAX	Maximum query latency
SUCCESS / ERROR	Success and failure count

CACHE (REDIS)

Panel	Description
CLIENTS	Redis client connection count
ALLOCATOR	Memory allocator status
KEY_COUNT	Number of stored keys
FRAGMENTATION	Memory fragmentation ratio

CEP (ESPER)

Panel	Description
JAVA_HEAP_USED	CEP engine heap memory
EVENT_INGESTION_RATE	Event ingestion rate
EQL_CPU_TIME	EPL query CPU time
EQL_MAP_COUNT	EPL map count
EVENT_INGEST_DIFF	Event ingestion difference
EVENT_DELAY_HISTOGRAM	Event delay distribution
CEP_STATEMENT_MATCH_RATE	Statement match rate
EQL_STATEMENT_OUTPUT_RATE	Statement output rate

META-STORE (POSTGRES)

Panel	Description
TOTAL_CONNECTIONS	Total connections
QUERY_LATENCY	Query latency
TOTAL_READS_HITS	Read hit count
TOTAL_DB_SIZE	Total DB size

EVENT-STORE (CASSANDRA)

Panel	Description
NATIVE_CLIENT	Native client connections
LATENCY	Read/write latency
READ_PER_SECONDS / WRITE_PER_SECONDS	Reads/writes per second
HEAP / DIRECT_MAPPED_MEMORY	JVM memory
CACHE / CACHE_HIT_RATE	Cache and hit rate
TOTAL_DATA_SIZE	Total data size
MEMTABLE	Memtable status
COMPACTION / COMPACTION_BYTES	Compaction status
TABLE_COMPACTIONS / TABLE_SSTABLE_COUNT	Compaction and SSTable per table
BLOOM_FILTER_FALSE_RATIO	Bloom filter false positive ratio
TABLE_READ_LATENCY / TABLE_RANGE_LATENCY / TABLE_WRITE_LATENCY	Latency per table
PENDINGS / FLUSH / THREAD_POOL	Pending, flush, thread pool
STATEMENT / COMMITLOG / EXCEPTION / MUTATION	Internal metrics
COMPRESSION / TOTAL_SSTABLE	Compression and SSTable status

TIMESERIES-STORE (TSE)

Panel	Description
TSE_MEMORY	Timeseries engine memory
TSE_HTTP_TIME	HTTP response time
TSE_DATASTORE	Datastore status
TSE_QUEUE_PROCESS_COUNT	Queue process count

ANALYTICS-STORE (SPARK)

Panel	Description
MEMORY_USED	Spark memory usage
CONNECTION	Connection count
OPERATION	Operation count
REQUEST_RATE	Request rate

---

3. PlantPulse - Edge Gateway

Dashboard for monitoring edge device status, PLC connections, and data reception.

Summary Panels

Panel	Description
Total Edge Gateways	Number of registered edge gateways
Power (Healthy/Abnormal)	Power status healthy and abnormal counts
PLC	PLC connection count
Total Data Capacity	Total collected data size
Received per Second Total	Total per-second receive sum across all edges (Gauge)
Maximum Data Receive Latency	Maximum receive latency (ms) (Gauge)
Log	Log status

PLC STATUS

Panel	Description
PLC Ping Failure Count	PLC connection ping failure trend
PLC Connected / Disconnected	PLC connection state trend
PLC Value Read Success Count	Data read success trend
PLC Data Read Failure Count	Data read failure trend
System Error Count Trend	System error trend

DATA POINT

Panel	Description
Total Sent per Second SUM(MPS)	Total per-second send sum across all edges
Point Transmission Count	Point transmission count trend
Transmitted Point Bytes	Transmitted data bytes
Receive Minimum/Average/Maximum Latency	Receive latency distribution

EDGE H/W

Panel	Description
CPU	Edge device CPU usage
Memory	Memory usage
Disk (SSD)	Disk usage
Network Upload/Download	Network traffic
Temperature	Device temperature

---

4. PlantPulse - Statistics

Dashboard for tracking long-term statistics such as daily data growth and peak resource usage. Useful for understanding long-term system growth trends.

Panel	Description
Total Data Capacity	Total stored data size
Daily Data Total Capacity	Daily data capacity trend
Daily Message Volume	Daily message count
Daily Data Growth	Daily data growth trend
Message Received Count	Message received count trend
Network Latency Average/Maximum	Network latency statistics
SSTABLE Growth	Cassandra SSTable growth trend
Maximum DB Client Connections	DB connection peak
Maximum Async Thread Execution Count	Async processing peak
Maximum JAVA GC Time	GC maximum duration
Maximum CQL Prepared Count	CQL Prepared Statement peak
Maximum Partition Size	Cassandra partition maximum
Minimum JAVA Heap Free Size	JVM heap minimum free
Maximum Async Thread Wait Count	Async queue maximum wait
Maximum Memory Buffer Size	Memory buffer peak
Backup Message Processing Count	Backup processing count

---

5. PlantPulse - Messaging

Dashboard for monitoring MQTT, Kafka, and WebSocket message broker status.

SUMMARY

Panel	Description
MQTT / KAFKA / WEBSOCKET	Connection status of each broker
CPU	Server CPU usage
JAVA_HEAP	JVM heap usage
NETWORK_READ_BYTES	Network receive bytes

MQTT

Panel	Description
CPU_USED	MQTT broker CPU (Gauge)
MEMORY_USED	Memory usage
CONNECTIONS	Client connection count
NETWORK IN/OUT	Network input/output
GC_COUNT / GC_TIME_MS	GC count and duration
THREAD_COUNT	Thread count
INCOMMING / OUTGOING	Incoming and outgoing messages
RETAINED_COUNT	Retained message count
SUBSCRIPTIONS	Subscription count
TOTAL_MESSAGE	Total message count

KAFKA

Panel	Description
CPU_USED	Kafka broker CPU (Gauge)
MEMORY_USED	Memory usage
GLOBAL_TOPIC	Global topic status
NETWORK IN/OUT	Network input/output
TOPIC_BYTE_IN/OUT_PER_SEC	Topic bytes per second
MESSAGE_PER_SEC_MEAN_RATE / 1M_RATE	Messages per second throughput
NETWORK_REQUEST_FETCH	Fetch request count
OFFLINE_PARTITION_COUNT	Offline partition count
ACTIVE_CONTROLLER_COUNT	Active controller count

WEBSOCKET

Panel	Description
CPU_USED	WebSocket server CPU (Gauge)
MEMORY_USED	Memory usage
CONNECTION_COUNT	WebSocket connection count
ENQUEUE / DEQUEUE	Queue input/output count

---

Monitoring Tool Integration

ELK Stack

You can build a log search and analysis environment by collecting container logs through a Filebeat → Logstash → Elasticsearch → Kibana pipeline. If you wish to efficiently manage logs in a large-scale operational environment, consider adoption. Container standard output is collected via docker logging driver, and file logs inside containers are collected via host mount (PLANTPULSE_LOG_DIR).