ВЕРСИИ (17)

## [3.3.0] - 2026-10-21 ### Fixed - `/perfreload` can enable the REST API again after a refused start (empty key, port taken); it restarts on bind/port/key changes. - Spike evaluation runs async instead of inside the lagging tick. - Discord webhooks have connect/read timeouts and honour Retry-After on HTTP 429. - ZGC/Shenandoah concurrent cycles no longer count as GC pause time. - Shutdown no longer overwrites hand edits of config.yml; config saves are atomic and coalesced. - Single-category mutes from `/perfsilent` survive logout. - Entity sweeps are rate-limited, and stale sweep results are no longer reported as incident causes. - Missing optional database drivers fall back instead of disabling the plugin; SQLite uses one connection; MySQL index creation works. - Language reloads no longer show raw keys in alerts; config merging no longer re-adds obsolete v2 alert types. - Language-file texts whose placeholders changed between versions fall back to the bundled text instead of showing `%s`/`%d` (named in one log warning). ### Changed - `/chunkstats` overview, `/entitystats` and `/worldstats` are disabled on Folia (cross-region access); `/perfincidents` and the REST API remain the location signal. - German texts use proper umlauts. ### Removed - Aliases `incidents`, `ps`, `silent` and `calibrate`; use `/perfincidents`, `/perfsilent`, `/perfcalibrate` or `pi`/`pc`.

## [3.2.1] - 2026-08-15 Things this version got wrong, all found by running it on a real server and reading back eight days of its own output rather than by reading the code. ### Changed - **A WARNING now means the tick rate suffered, and it has to hold.** Two rules decided it before, and both fired on servers that were fine. The tail bound `p95 >= 50` warned on production at p95 51.3 ms while the rate sat at 19.9 TPS — one tick in twenty a hair past the deadline, nothing anyone could feel. And nothing required the trouble to last: a five-second login burst and a fourteen-second redstone burst each opened an incident. A WARNING is now `TPS < 19` or a 35 ms average, and it has to hold for `alerts.warning_sustain_seconds` (default 30) before an incident opens. CRITICAL and above skip the wait — below 17 TPS or at a 50 ms average the server is already failing and waiting would be absurd. The incident is dated from when the trouble started and carries the peaks measured during the wait, so this filter cannot quietly shorten what it lets through. ### Fixed - **Seventeen WARNING incidents for "somebody is playing".** A baseline deviation alone opened an incident, and on a server that idles at 3.5 ms the first player who logs in is a fourfold jump — `normal * 2 + 10` is crossed by ordinary play. Measured on production: 17 WARNINGs in eight days, every one at 14–19.5 ms average tick with TPS never below 19.8, each coinciding with one or two players online. A deviation now needs the absolute load to be meaningful as well (avg ≥ 25 ms, half the deadline, or p95 ≥ 35 ms) before it reaches WARNING; below that it is a NOTICE, which is recorded but opens no incident. Genuine degradation still escalates — a server drifting to 26 ms average warns as before. The gate first carried a tail arm as well (p95 ≥ 35 ms), which let the same noise straight back in: on rattenkolonie, idling at 0.2 ms, a player logging in produced avg 11.1 ms with a p95 between 35 and 50 ms — five seconds of chunk loading — and opened a WARNING. A tail that genuinely hurts is already a WARNING through the absolute `p95 >= 50` rule, so the arm bought no detection and only cost quiet. The gate is the average alone. - **The cause showed up late, and then under a name that said nothing.** `hotChunks()` only ever exposes the last *completed* 10-second activity window, so the report an incident opens with could be built from data up to ten seconds old — and a lag source that had just started was not in it at all. The window is now closed on the spot when an incident opens; rates divide by the window's real elapsed time, so a short one under-reports slightly rather than inventing load. And the finding is titled by what is actually going on — "Hochaktives Redstone/Pistons in Vorbau bei 192, 48" instead of "Hochaktiver Chunk" — because the incident list and the Discord alert show the title alone, while the plugin knew the answer all along and kept it in the detail line. - **A login was not attributed.** Teleports were, but the case that produced the complaint was a player logging in — same physics, chunks around the logout point being read or generated, and it still reported "no clear cause". Both now share one finding (`PLAYER_ARRIVAL`). Unlike the world-save and command markers it is *not* pinned above the measured findings: an arrival overlapping an incident is a correlation, not proof, so it takes part in the normal sort and surfaces only when nothing measured outranks it. - **Every incident was reported 30 seconds longer than it lasted.** An incident resolved at the end of the grace period, and that timestamp became its end time, so the fixed `RESOLVE_GRACE_MS` was billed to every duration. A 12-second blip on production was announced as "Dauer: 42s". Incidents now end when the server recovered; the grace period remains what it always was — confirmation that the recovery held. - **The database dropped measurements in three places.** `drain` polled an entry and *then* checked whether the batch was full, discarding exactly one measurement on every capped flush. A failed write lost its whole batch: the entries had already left the queue, and the failure path only rescued what was still queued, so the first batch after an outage went nowhere — it is now written to the fallback file, together with whatever else piled up. And `shutdown()` flushed a single batch of at most 1000 entries before closing the pool, which is the one moment a backlog is likely; it now drains completely. If no fallback file is configured the loss is at least logged instead of silent. - **`ChunkTracker` kept every heavy chunk it ever saw.** One entry per chunk above the tile/entity warning thresholds, never evicted, on a map with no upper bound — so it grew for as long as the server ran, and pregeneration or exploration grew it fast. Capped at 4096 like the equivalent map in `ActivityCounters`; chunks skipped once full are counted rather than ignored. - **`/perfreload` did not apply the settings the config GUI offers.** Packet analysis, listener timings and the REST API were wired up at enable time and never touched again, so toggling them and reloading did nothing at all while the GUI said "takes effect after restart or /perfreload". All three now start and stop on reload. `ListenerTimings` is always constructed for this reason — its consumers take the reference once, so a null could never have become non-null again — and `isActive()` carries the on/off state. - **Calibration called `Bukkit.getOnlinePlayers()` off the tick thread**, in a class whose contract says it runs async by design. It now reads the monitor's main-thread sample. - **WorldEdit operations and teleports ended in "no clear cause"** while the reason sat two lines above in the server log. Neither is visible to any of the instrumented sources: the work happens inside the command or the teleport, not in a listener, a chunk counter or a GC pause. Both now set a cause marker like the world save does — verified against `//paste` (TPS 15.5), `/mv delete` + `/mv create` ("Prepared spawn area in 4083 ms") and `/home` jumps producing 778 ms ticks. Command matching is driven by `attribution.expensive_commands` and deliberately short, because anything on that list can collect the blame for a stall it merely overlapped; teleports under 256 blocks within one world are ignored, their destination being loaded already. - **Calibration could tighten a threshold an admin had deliberately raised.** The floor protected only the shipped default, so it did nothing for any install that had ever changed a value. Found on production, where `packet_flood_per_tick` sat at 3000 after 671 real alerts between 1002 and 5104 packets/tick had proven 1000 too tight — and calibration proposed pulling it straight back to 1000, which would have reinstated every one of those alerts. The measurement behind the proposal was 49 packets/tick from a one-minute window on an empty server; the packet counter itself is sound and resets every tick, in v2 as in v3. Every proposal now floors at `max(shipped default, value in effect today)`, so calibration can widen a limit and never narrow one. `startup_grace_seconds` follows the same rule: one fast boot is a single observation, and shortening the grace is what brought the phantom boot incidents back — production's deliberate 120 s is no longer halved by a 34 s boot. - **A floored value was justified with a formula that produced a different number.** "p99 x 2" printed under a proposal of 1000 when p99 x 2 was 98. When a floor decides the value, the reason now says so and names what the sample actually suggested. - **`/perfcalibrate` refused to run because worlds were idle.** Unloaded worlds vetoed the entire calibration once more than a third of them had no loaded chunks — and on a normal server that is the normal state: nobody is in the nether, so the nether has no chunks. Two worlds with one of them quiet was already enough to block. The veto also discarded `spike_tick_ms`, `packet_flood_per_tick` and `startup_grace_seconds`, none of which have anything to do with worlds. The guard existed to stop a thin spatial sample from proposing tight world thresholds, but that job is already done twice over: every proposal is floored and so can only ever relax (`idleSampleCannotTighten…` covers exactly the 6-of-9-worlds case), and the sampler skips empty worlds instead of recording a zero for them, so they never drag the percentiles down. Unloaded worlds are now a warning naming how many worlds *were* measured, and calibration proceeds.

## [3.2.0] - 2026-08-09 Adds threshold calibration, so a fresh install no longer has to guess the values that decide when it complains. ### Added - **`/perfcalibrate`** derives threshold values from what the server actually did, shows the proposal and writes nothing until confirmed with `/perfcalibrate apply`. `/perfcalibrate revert` restores the config from before the last run. Only thresholds (plus the measured `startup_grace_seconds`) are written; findings outside that scope — a port already in use, a missing soft dependency — are reported as notes and left alone. - **Guard rails against calibrating a bad moment.** The command refuses to run while the server is not OK, while an incident is open, on a sampling window shorter than 30 minutes, when no player was online for the whole window, and when more than a third of the worlds have no chunks loaded. A thinner but real sample only warns. Thresholds do not adjust themselves afterwards: a threshold that follows its own measurements upward lets a slowly degrading server raise its own bar until nothing is ever reported. - **Calibration may only relax a threshold, never tighten it** below the shipped default. Its purpose is to stop false alarms, which means raising limits; a tighter limit buys no better detection, only noise — the adaptive half of detection is the learned tick baseline, not these backstops. Found by testing: a 34-minute window on an idle server proposed `spike_tick_ms` 100 → 52 and `world_entity_warning` 5000 → 500, values that would have alerted on ordinary play. The old representativeness check could not catch it either, because on a server that never had players the median player count is 0 and `0 < 0` is false. - **New metric series `players_online` and `chunks_loaded`** in the 60-second logging path, sampled from the tick thread. Without them nothing could tell a quiet server from a healthy one after the fact. - **`ProtocolLibHook` now records the observed packets-per-tick peak.** The stored packet series are cumulative counters whose per-interval deltas average every spike away. - **Stalls outside the tick loop are detected and attributed.** Work that blocks the main thread without completing a tick — loading or generating a world, blocking I/O in a plugin, the host itself freezing — fires no `ServerTickEndEvent`, so tick times stayed healthy while TPS collapsed and the incident ended in "no clear cause". Observed on production: `/mv create` froze the server for 4 s and the worst recorded tick was 12 ms. The gap between two tick ends now exposes exactly that time, needs no new instrumentation, and by construction cannot double-count a long tick: a 7-second `save-all` is already its own duration and leaves nothing unaccounted. - **`alerts.dampen_world_save`** (default `true`) stops the nightly backup from paging anyone. `save-all` blocks the tick loop for as long as the worlds need — 7 s on a 25 GB install — and is correctly measured as an EMERGENCY-grade stall, but it is scheduled and harmless. The incident is still recorded in full and visible in `/perfincidents`; only the alert is withheld, so the measurement stays honest. Set to `false` while investigating slow disks. ### Fixed - **Config migration never added missing keys.** Two independent causes: the whole add-missing-key block sat behind an early `config_version` check, and presence was tested with `contains()`, which counts the jar-embedded defaults and therefore reported every key as present. Both are gone; the migration is idempotent and runs on every start, matching the obsolete-key cleanup. Observed on a production install carrying `config_version: 7` with no `api`, `alerts` or `gui` section at all. - **Migration entries added** for `performance.startup_grace_seconds`, `thresholds.spike_tick_ms`, `database.fallback_file_logging`, `database.fallback_log_file` and the four v3.1.0 `discord.alert_types` subkeys, none of which had one. - **`ChunkTracker` ignored its configuration.** `chunk_tile_entities_threshold` and `chunk_entity_warning` were hardcoded at 50 and 30, so `/chunkstats problems` answered from constants and the config keys did nothing. - **A busy API port now says so.** `BindException` is reported with the likely cause (squaremap, dynmap and BlueMap all default to 8080) instead of a bare "address already in use".

## [3.1.0] - 2026-08-07 Complete rewrite. PerformanceAnalyzer is now a pure performance plugin with an honest measurement core, an incident-based root-cause engine and a real REST API. The AntiCheat module moved into its own plugin, **BS-AntiCheat**. ### Changed - **MSPT now means real tick work time (BREAKING for dashboards).** v2.x measured the *tick interval* — the time between scheduler runs, which is pinned to ~50 ms on any healthy server. That was the root cause of the permanent false alerts. v3 measures the actual per-tick work duration via Paper's `ServerTickEndEvent`: a healthy server now shows single-digit MSPT, and 50 ms is the deadline at which 20 TPS can no longer be held. Exported MSPT values will drop dramatically after upgrading — the new values are the correct ones. - **Statistics over fixed time windows** (10 s / 60 s) with p50/p95/p99/max percentiles instead of fixed tick counts; a single spike is caught, not averaged away. TPS is counted exactly on Paper and estimated from the worst region on Folia. - **Fixed alert thresholds replaced by a documented severity model** (`analysis/SeverityModel.java`): OK/NOTICE/WARNING/CRITICAL/EMERGENCY plus a transparent 0–100 score (45 pts sustained load vs. the 50 ms deadline, 30 pts p95 tail latency, 25 pts GC pressure). `thresholds.mspt`, `thresholds.tps_drop` and `thresholds.heap_usage` are gone; only `thresholds.spike_tick_ms` and `thresholds.packet_flood_per_tick` remain. - **One-shot "performance drops" became incidents** with an open → escalate → resolve lifecycle, duration tracking and a resolved notification. `/perfincidents` (aliases `pi`, `perfdrops`, `incidents`) replaces `/perfdrops`. - **Root-cause attribution is ordered and confidence-labeled**: findings are marked MEASURED or HEURISTIC and checked world save/backup → GC → plugin listener timings → hot chunks → chunk generation/churn → entity hotspots, so a GC-caused spike is never blamed on redstone. Tick stalls within 12 s of a `WorldSaveEvent` (autosave, backup `save-all` — the nightly false alarm source) are pinned to the save as the top finding. - **Plugin analysis measures real cost**: `timing/ListenerTimings.java` wraps other plugins' event handlers and accumulates actual milliseconds per plugin, replacing the `listeners*2 + tasks*3` registration-count risk score that reliably blamed the wrong plugin. - **Chunk analysis counts activity, not existence** (`ActivityCounters`): per-chunk redstone firings, piston movements, hopper item moves, spawns and chunk loads/gens per second in rolling 10 s windows replace the static redstone/block estimator (idle contraptions cost nothing; a 10 Hz clock costs real time). - **Detection decoupled from database logging**: the evaluation loop runs every second regardless of DB state (v2 detection ran once per minute as a side effect of DB logging and stopped when the DB was down). - `/perfhistory` now queries asynchronously and clamps its range; its permission (`performance.history`) and `performance.gui` default to op. - Alerts are severity-based with escalation and a resolved message, dispatched thread-safely to players with `performance.alerts`; Discord embeds are colored by severity and use new `discord.alert_types` keys: `incident_opened`, `incident_escalated`, `incident_resolved`, `packet_flood`, `performance`. - Config migrated automatically to `config_version: 7` — obsolete keys are deleted, new keys added with safe defaults. ### Added - **Adaptive baseline** (`analysis/Baseline.java`): EWMA over ~10 minutes of healthy samples (120-sample warmup); the severity model alerts on deviation from the server's *own* normal in addition to the hard 50 ms deadline. The baseline is only fed while the server is healthy, so an ongoing incident cannot poison it. - **GC monitoring** (`metrics/GcSampler.java`): GC pause-time deltas, old-gen occupancy *after* the last collection (the only honest memory-pressure signal — 90 % live heap right before a young GC is normal) and metaspace. - **Single-tick spike trigger**: one tick above `thresholds.spike_tick_ms` (default 100 ms) starts incident analysis immediately, rate-limited. - **Real REST API** (`api/MetricsAPI.java`): `GET /api/health` (no auth), `/api/metrics`, `/api/incidents`, `/api/worlds` and Grafana-ready `/api/metrics/prometheus` (text exposition v0.0.4). Constant-time `Authorization: Bearer` check, `api.bind` defaults to `127.0.0.1`, and the server refuses to start while `api.key` is empty or `"changeme"`. - **Folia support**: `folia-supported: true`; all tasks go through the region-aware schedulers (`platform/Scheduling.java`). Tick samples come from every region thread; TPS is a worst-region estimate on Folia. - Fallback file logging when the database is unavailable (`database.fallback_file_logging`, `database.fallback_log_file`). - JUnit 5 unit tests for the pure logic (Baseline, SeverityModel, TickStats) wired into the Maven build via Surefire. - Anonymous [bStats](https://bstats.org/plugin/bukkit/PerformanceAnalyzer/32115) usage metrics (shaded & relocated; opt-out via `plugins/bStats/config.yml`). ### Fixed - **The analyzer no longer freezes the server during lag**: the v2 analyzer took chunk snapshots and iterated worlds on the main thread mid-incident, blocking for seconds. The v3 engine attributes causes exclusively from already-collected data — no chunk snapshots, no main-thread blocking, no Bukkit access from HTTP or monitor threads. - **Fixes from live verification on Paper 26.1.2, Paper 1.21.4 and Folia 26.2 (2026-08-05 … 2026-08-07):** - Plugin crashed on enable when ProtocolLib was absent (`NoClassDefFoundError` — the presence check now runs before the first hook-class reference). - Folia fires no `ServerTickEndEvent`; the interval fallback recorded the ~50 ms tick *period* as work time and produced a permanent false WARNING. Healthy fallback samples now use a nominal value and `/perfstatus` labels the estimate mode. - Scheduled restarts raised a bogus CRITICAL/EMERGENCY on every shutdown (counted TPS collapses while worlds save) — evaluation is now suspended once `Bukkit.isStopping()` and during the new startup grace period (`performance.startup_grace_seconds`, default 60 s; metrics still run). - The baseline learned during NOTICE, letting sustained load ratchet the "normal" value upward until active incidents self-resolved; it now learns only while the severity is OK. - Entity-hotspot findings multiplied chunk coordinates by 16 twice (reported "-256, 0" instead of "-16, 0"). - TPS windows are clamped to the sampler uptime (the first minute after boot divided by a window that had not filled yet and reported bogus low 60 s TPS). - Incident open/escalate/resolve messages are always written to the console (WARNING-level incidents were chat-only and invisible on empty servers). - The shutdown config save runs only when the plugin itself changed the config — the unconditional save wiped `config.yml` edits admins made while the server was running. - Obsolete-key cleanup is now version-independent and idempotent: configs stamped with a matching `config_version` by older builds kept dead sections (the `anticheat:` block survived a 6→7 migration), and the removal list used a wrong key name (`thresholds.heap_usage` vs. `heap_usage_percent`). - `/perfhistory` results are additionally written to the server log for console/RCON senders (async replies never reach the RCON response). - Severity assessment reasons are localized (were hardcoded German). - GUI refresh-task leak fixed; all GUIs now share a single registered listener (`GuiManager`) instead of per-GUI listeners and throwaway instances. GUI texts fully localized (en/de). - Permanent false "high MSPT" alerts on idle servers (see the measurement change above). - CI artifact upload glob matched nothing (`PerformanceAnalyzer-*.jar` vs. actual `performance-analyzer-*.jar`). ### Removed - **AntiCheat module** — now the separate plugin **BS-AntiCheat**. Gone with it: `/acwhitelist`, `/xrayalerts`, `/xrayores`, `/movealerts`, the `performance.anticheat.*` permissions and the `anticheat.*` config section (deleted by migration). - **Auto Entity Cleaner** (`entity_cleaner.*` config section). - Static redstone estimator, `PerformanceDropAnalyzer` and the plugin "risk score" (replaced as described above). - Fixed `thresholds.mspt` / `thresholds.tps_drop` / `thresholds.heap_usage` and the `messages.*` config section. - `discord.alert_types.anticheat` (deleted by migration); the old `high_mspt`/`tps_drop`/`high_heap` Discord alert keys are no longer consulted (replaced by the incident-based keys). - `docs/grafana-dashboard.json` — use the Prometheus endpoint with your own Grafana dashboards instead.

## [3.0.0] - 2026-06-17 ### Changed - **BREAKING: AntiCheat split into a separate plugin (BSAntiCheat).** PerformanceAnalyzer is now a focused performance-monitoring & lag-diagnosis plugin. All XRay and Movement detection — including the related commands, GUI, config, permissions and language strings — has been removed from this plugin and lives on in the standalone **BSAntiCheat** plugin. The performance GUI detects BSAntiCheat and links to it when installed. - **Performance drop detection now runs every second** on its own scheduled task, decoupled from the database logging interval. Previously `checkForDrop()` was only called once per `log_interval_seconds` (60s by default), so short-lived TPS/MSPT spikes were missed. ### Added - **REST API is now active.** The `MetricsAPI` server is started on enable (was previously implemented but never wired up). Endpoints: `/api/health`, `/api/metrics`, `/api/worlds`, `/api/trends`, with API key authentication. Disabled by default. - **Auto Entity Cleaner is now active.** `AutoEntityCleaner` is hooked into plugin enable/disable. Disabled by default with `dry_run: true`. - **Developer API**: `PerformanceAnalyzer` now implements the public `PerformanceAPI` interface — `getCurrentTPS()`, `getCurrentMSPT()`, `getHeapUsagePercent()`, `getTotalEntityCount()`, `getEntityCount(World)`, `getVersion()`. - **Accurate low/high drop tracking**: recorded performance drops now report the actual worst TPS / highest MSPT observed during the drop window instead of the value at the moment of recording. - **Documented config keys** that were previously only added silently via migration: `database.fallback_file_logging`, `database.fallback_log_file`, `gui.auto_refresh`, and the full `api.*` and `entity_cleaner.*` sections. ### Fixed - **Duplicate logging task / task leak on `/perfreload`**: `TickSampler.setDatabase()` now cancels the previously scheduled logging task before scheduling a new one. Previously every reload added another logging task, causing duplicate database writes and duplicate alert/drop checks. - **Verbose console output during lag events**: the per-world / per-chunk diagnostic logging in the performance drop analyzer is now gated behind debug mode, so it no longer floods the console (and adds load) while the server is already struggling. - **Throttled deep analysis**: the expensive server-state/chunk-snapshot analysis now runs at most once per 30 seconds during sustained drops, preventing it from piling up chunk snapshots on the main thread. ### Removed - AntiCheat classes: `XRayDetector`, `MovementChecker`, `ViolationTracker`, `XRayAlertManager`, `MovementAlertManager`, `AntiCheatGUI`, `LuckPermsHook` - AntiCheat commands: `/xrayalerts`, `/movealerts`, `/xrayores`, `/acwhitelist` - AntiCheat permissions: `performance.anticheat.manage`, `performance.anticheat.bypass` - All `anticheat.*` config keys, `performance.anticheat_enabled`, `discord.alert_types.anticheat`, and all AntiCheat/XRay/Movement language strings (EN & DE) - `XRAY` and `MOVEMENT` silent-mode categories — only `ALL` and `PERFORMANCE` remain; `/perfsilent` now accepts `all`, `performance`, `list`, `reset` - Dead code: unused `ConfigMigrator` class (a duplicate migration system with a phantom "prometheus" feature), legacy synchronous `analyzeChunk()`, `DatabaseManager.deleteAntiCheatLogs()`, `isPlayerSuspicious()` from the public API, and empty Javadoc stubs in `Constants` ### Config - `config_version` bumped to **6** — auto-migration adds the new fallback-logging keys to existing configs (existing settings are never overwritten)

## [2.3.4] - 2026-05-07 ### Fixed - **Redstone False Positives in Performance Drop Analyzer**: Removed 26 non-performance-impacting blocks (buttons, pressure plates, lecterns, daylight detectors, tripwire, levers, targets) from `isRedstoneComponent()`. These blocks appear in naturally generated structures (villages, temples) and caused massive false positives through sampling extrapolation - **Redstone Sampling Extrapolation**: Added minimum threshold (≥3 components found) before extrapolating redstone counts. Previously, a single naturally-generated button was multiplied by ×64, producing false "problematic redstone" reports - **Wrong Coordinates in Problematic Chunk Reports**: Chunk coordinates are now displayed alongside block coordinates (`[Chunk X,Z | Blocks ~X,Z]`) for easier in-game navigation - **NullPointerException in PerformanceDropAnalyzer**: `worldInfo.get("name").equals(...)` replaced with `Objects.equals()` to prevent NPE when world name is null - **Swallowed Exceptions in Chunk Analysis**: ChunkSnapshot and synchronous chunk analysis errors are now logged at `FINE` level instead of being silently ignored - **Unbounded Database Queue (OOM Risk)**: `DatabaseManager.logAsync()` now enforces a maximum queue size of 10,000 entries. Prevents `OutOfMemoryError` when the database is unavailable for extended periods - **Excessive Block Checks in MovementChecker**: `isNearLiquid()` reduced from 27 block checks (3×3×3 cube) to 7 checks (current block + 6 adjacent faces), reducing CPU load per `PlayerMoveEvent` by ~74% - **Duplicated Alert Cooldown Constants**: `AlertManager` and `MovementAlertManager` now use the centralized `Constants.ALERT_COOLDOWN_MS` instead of defining their own identical values - **Silent Config Parsing Failures**: Invalid alert categories in `AlertPreferenceManager` now log a warning instead of being silently skipped - **Thread-Safety in WorldStatsManager**: Trend history lists now use `Collections.synchronizedList()` to prevent concurrent modification issues ### Added - `Constants.DB_MAX_QUEUE_SIZE` — centralized maximum queue size for database log entries

## [2.3.3] - 2026-04-12 ### Fixed - **Sneaking/Swimming/Climbing False Positives**: These movement types are now skipped entirely by the speed checker. - **Silk Touch Ores Not Recognized as Self-Placed**: The player-placed block check now applies to ALL worlds, not just restricted worlds. Previously, silk-touching an ore block, placing it in your base, and breaking it would count toward XRay detection - **Y-Level Pattern Analysis Removed**: Completely removed the Y-Level analysis feature. Mining at optimal Y-levels is normal gameplay (anyone can Google "best Y level for diamonds") and produced false positives ### Removed - `analyzeYLevelPattern()`, `trackYLevel()`, `getOptimalYRange()` methods from XRayDetector - `playerOreYLevels` tracking map from XRayDetector - `xray_ylevel_high/medium/low` config entries and validation - `XRAY_YLEVEL` violation type

## [2.3.2] - 2026-04-11 ### Fixed - **Race Condition in AlertManager**: Cooldown check now uses atomic `compareAndSet()` instead of separate `get()`/`set()`, preventing duplicate alerts under concurrent access - **Race Condition in TickSampler**: Tick sampling now uses `idx.getAndUpdate()` for atomic index read-modify-write, preventing data corruption in the nanos array - **Connection Pool Leak in DatabaseManager**: `shutdown()` now uses try-finally to ensure `HikariDataSource.close()` is always called, even if `flushBatchSafe()` throws an exception - **NullPointerException in GUIs**: Added null-checks for `getItemMeta()` in all GUI classes (PerformanceGUI, AntiCheatGUI, LagAnalysisGUI, PerformanceDropsGUI) — follows the safe pattern already used in ConfigGUI - **Thread-Safety in ViolationTracker**: `resetViolations(UUID, ViolationType)` now uses `computeIfPresent()` to prevent race condition where the PlayerViolations object could be removed between `get()` and `counts.remove()` - **MovementChecker Violation Reset Too Aggressive**: Consecutive violation counters now only reset when speed is significantly below threshold (70%), preventing a single valid move from immediately washing out violations - **XRay Y-Level Thresholds Too Aggressive**: Default thresholds raised from 75%/65%/55% to 85%/75%/65% to reduce false positives from legitimate caving - **UpdateChecker Missing Field Validation**: Now checks for `version_number` field existence in Modrinth API response before accessing it - **Inconsistent Activity Weights**: `PlayerActivityTracker.getTotalActivity()` now uses centralized `Constants.ACTIVITY_WEIGHT_*` values instead of hardcoded numbers ### Added - **Configurable XRay Y-Level Thresholds** (`config.yml`) - `anticheat.xray_ylevel_high` (default: 0.85) — percentage for maximum suspicion - `anticheat.xray_ylevel_medium` (default: 0.75) — percentage for moderate suspicion - `anticheat.xray_ylevel_low` (default: 0.65) — percentage for low suspicion - Config validation ensures values are 0.0-1.0 and properly ordered (low < medium < high) - Auto-migration adds defaults for existing configs ### Changed - `XRayDetector.analyzeYLevelPattern()` reads thresholds from config instead of using hardcoded values

## [2.3.1] - 2026-04-10 ### Added - **Silent Mode / Streamer Mode** (`/perfsilent`) - Toggle all alerts on/off: `/perfsilent` - Toggle per category: `/perfsilent xray`, `/perfsilent movement`, `/perfsilent performance` - Reset all preferences at once: `/perfsilent reset` - View current status: `/perfsilent list` - Persistent across server restarts (saved in `config.yml` under `alerts.silent_players`) - Aliases: `/ps`, `/silent` - Full tab-completion support - Bilingual: German & English language strings - **AntiCheat DB Cleanup Commands** - `/movealerts clear <player> --db` — deletes movement violation entries from the database - `/xrayalerts clear <player> --db` — deletes XRay detection entries from the database - Without `--db`: only clears in-memory alerts (as before), now shows a hint about the `--db` option - Tab-completion for `--db` flag - **Teleport Immunity for Movement Checks** - New `PlayerTeleportEvent` listener prevents false positives from legitimate teleports (`/tp`, `/home`, ender pearls, etc.) - 1-second grace period after any teleport where movement checks are skipped - `lastLocations` reset to teleport destination to prevent follow-up false positives - Consecutive violation counters reset on teleport ### Fixed - **Version Inconsistency**: pom.xml, plugin.yml, and main class now use the same version dynamically via `getDescription().getVersion()` instead of hardcoded strings - **Race Condition in AsyncConfigSaver**: `pendingSave` changed from `volatile boolean` to `AtomicBoolean` with proper atomic check-and-set operations, preventing lost config saves under concurrent requests - **NullPointerException in PerformanceDropAnalyzer**: Added null-checks for `Player.getWorld()` and `Player.getLocation()` during world unload scenarios - **Memory Leak in AlertManager**: Added periodic cleanup task (every 5 minutes) for stale `lastAlertTimes` entries that were never removed - **AntiCheat False Positives**: Improved lag compensation from linear to square-root scaling (200ms ping = +10%, 500ms = +20%, 1000ms = +30%), reducing false positives for high-ping players without allowing extreme speeds ### Changed - All three alert systems (`AlertManager`, `XRayAlertManager`, `MovementAlertManager`) now respect per-player alert preferences before sending chat notifications - Config auto-migration adds `alerts.silent_players` for new installations

## [2.3.0] - 2026-02-22 ### Added - **Lag Compensation for Movement Checks** - Player ping considered in speed calculations (+10% per 100ms above 100ms) - Reduces false-positives for high-ping players - **Knockback/Damage Immunity Detection** - 2-second immunity window after explosions and entity attacks - Prevents false-positives from legitimate knockback - **Y-Level Analysis for XRay Detection** - Tracks mining height for all ores - Optimal Y-level ranges based on Minecraft 1.21 - New detection method: `XRAY_YLEVEL` - Detects suspicious pattern: 75%+ mining at optimal height - **Async Chunk Analysis** - Uses `ChunkSnapshot` for thread-safe analysis - Parallel processing with `CompletableFuture` - **90% less main-thread load** during performance drop analysis - Timeout protection maintained - **Auto-Cleanup for Database** - Automatic retention policy (default: 30 days) - Runs daily (1h after startup, then every 24h) - Configurable: `database.retention_days` (set to 0 to disable) - **GUI Auto-Refresh System** - Performance data updates every 3 seconds - Only active for open GUIs (no overhead) - Automatic cleanup on GUI close - Configurable: `gui.auto_refresh` - **Trend Analysis for World Stats** - Historical tracking (up to 288 snapshots = 24h @ 5min intervals) - Trend direction: `INCREASING`, `DECREASING`, `STABLE` - Change rate calculation (entities/hour) - Methods: `recordSnapshot()`, `analyzeTrend()`, `analyzeTrendsForAllWorlds()` - **REST API for External Monitoring** - 4 JSON endpoints: `/api/health`, `/api/metrics`, `/api/worlds`, `/api/trends` - API key authentication (`Authorization: Bearer`) - Perfect for Grafana/Prometheus dashboards - Config: `api.enabled`, `api.port`, `api.key` - **Automatic Entity Cleaner** - Smart entity management to prevent lag - Priority-based removal (items → projectiles → monsters → animals) - Protection for named entities, tamed animals, villagers - Boss mob blacklist (Ender Dragon, Wither, Warden) - Per-world and per-chunk limits - Dry-run mode for safe testing - Config: `entity_cleaner.*` ### Changed - **Movement Checker** (`MovementChecker.java`) - Added environmental checks (slime blocks, bubble columns) - 2x vertical speed allowance near slime blocks/bubble columns - Enhanced cleanup method to include new tracking maps - **XRay Detector** (`XRayDetector.java`) - Added Y-level tracking for pattern analysis - New method: `analyzeYLevelPattern()` - New method: `getOptimalYRange()` with Minecraft 1.21 spawn data - Enhanced `checkSuspiciousPattern()` with Y-level analysis - **Performance Drop Analyzer** (`PerformanceDropAnalyzer.java`) - Replaced synchronous chunk analysis with async processing - Added `analyzeChunkAsync()` method using ChunkSnapshot - Legacy `analyzeChunk()` kept as fallback - Improved error handling for async operations - **Database Manager** (`DatabaseManager.java`) - Added auto-cleanup task for retention management - Enhanced shutdown procedure to cancel cleanup task - **World Stats Manager** (`WorldStatsManager.java`) - Added trend tracking infrastructure - New records: `WorldStatsSnapshot`, `TrendAnalysis` - Multiple helper methods for trend calculation - **Performance GUI** (`PerformanceGUI.java`) - Added auto-refresh system with task management - New `InventoryCloseEvent` handler for cleanup - New method: `shutdown()` for proper cleanup - **Plugin Config** (`PluginConfig.java`) - Added 10 new config methods for features - Auto-migration for all new config entries ### Fixed - Memory leaks from incomplete cleanup (movement checker, XRay detector) - False-positives in movement detection from knockback - False-positives in movement detection from environmental effects - Main-thread bottleneck in chunk analysis ### Performance - **90% reduction** in main-thread load during performance drop analysis - Reduced false-positive alerts (less CPU overhead) - More efficient memory usage with automatic cleanup ### Security - REST API authentication with API keys - SSRF protection in Discord webhook validation (from v2.2.0) - SQL injection prevention (from v2.2.0)

## [2.2.0] - 2026-01-05 ### 🏗️ Major Release - Stability & Performance Update This release focuses on **security hardening**, **graceful degradation**, **performance optimizations**, and **critical bug fixes** to ensure stable operation on production servers. ### 🔐 Security Hardening #### SQL Injection Prevention - **Type-Safe Database Queries** - New `TimeUnit` enum for SQL time unit operations - Replaces dangerous string concatenation in `DatabaseManager` - Prevents SQL injection attacks via time-based queries - Enum values: `SECOND`, `MINUTE`, `HOUR`, `DAY` - Each value provides safe SQL name via `getSqlNameUpper()` #### SSRF Protection - **Discord Webhook URL Validation** - Protocol validation: HTTPS-only (HTTP rejected) - Domain whitelist: Only `discord.com` and `discordapp.com` allowed - Path validation: Must start with `/api/webhooks/` - Prevents Server-Side Request Forgery attacks - Logs validation failures for security monitoring #### Memory Leak Prevention - **Size Limits on All Maps** - `XRayDetector.playerPlacedBlocks` - Max size: 10,000 entries - `XRayDetector.playerOreMines` - **NEW**: Max size: 5,000 players - `XRayDetector.playerStoneMines` - **NEW**: Max size: 5,000 players - `MovementChecker.moveCounter` - Periodic reset at threshold - Automatic cleanup routines prevent unbounded growth - Warning logs when size limits are hit - Debug logging shows cleanup statistics and map sizes ### 💾 Graceful Degradation #### FallbackLogger System - **Automatic Database Failover** - Queue-based async file writing (`ConcurrentLinkedQueue`) - CSV format: `timestamp | type | value | description` - Detects 3 consecutive database failures - Switches to file logging automatically - Configurable flush threshold (default: 100 entries) - File rotation and management - Fallback file path: `plugins/PerformanceAnalyzer/fallback.log` #### Database Availability Monitoring - **Failure Detection** - `isDatabaseAvailable()` method for health checks - Consecutive failure counter - Automatic recovery detection (resets to DB logging) - Logs critical warnings when switching modes #### Configuration ```yaml fallback_logging: enabled: true file: "plugins/PerformanceAnalyzer/fallback.log" ``` ### ⚡ Performance & Reliability #### AsyncConfigSaver (CRITICAL FIX) - **Thread-Safe Config Operations** - **FIXED**: Now uses Bukkit Scheduler instead of ForkJoinPool - **CRITICAL**: `saveConfig()` runs on main thread (Bukkit requirement) - Previously used `CompletableFuture.runAsync()` which caused ConcurrentModificationException - Uses `CompletableFuture` for async pattern - Atomic boolean flags prevent concurrent saves - `saveAsync()` schedules on main thread via `runTask()` - `saveSyncOnShutdown()` ensures data persistence on server stop - Error handling with exception logging and stack traces - Prevents thread-safety violations and data corruption #### Performance Optimizations - **Event Sampling** - Movement checks reduced by ~90% - Only every 10th PlayerMoveEvent processed - OR significant distance (>2 blocks) always checked - Counter reset at 1000 to prevent overflow - Minimal detection accuracy loss - **Database Indexing** - Indexes on `timestamp` column for time-range queries - Indexes on `type` column for metric filtering - Significantly faster query performance - Auto-created during database initialization #### Constants Class - **Centralized Configuration** - 255 lines of well-organized constants - Categories: Database, Discord, Movement, XRay, Performance, Vehicle Speeds - No more magic numbers scattered throughout codebase - Easy to tune and maintain - All values documented with comments ### 🏗️ Architecture Improvements #### CommandRegistry System - **Modular Command Registration** - Replaces 112-line monster method in `PerformanceAnalyzer` - Separate methods for each category: - `registerPerformanceCommands()` - /perfstatus, /perfhistory, /perfreload - `registerAnalysisCommands()` - /worldstats, /entitystats, /chunkstats, /perfdrops - `registerGUICommands()` - /perfgui - `registerAntiCheatCommands()` - /acwhitelist, /xrayalerts, /movealerts, /xrayores - Easy to extend with new commands - Clean separation of concerns - AntiCheat commands dynamically registered when module enabled #### ConfigMigrator Class - **Extracted Migration Logic** - Separate class for config version upgrades - Version-by-version migration (v0 → v1 → v2 → ... → v5) - Only runs when `config_version < Constants.CONFIG_VERSION` - Returns boolean if changes were made - Cleaner `PluginConfig` class (separation of concerns) - Easy to add new migrations #### Public API - **PerformanceAPI Interface** - `double getCurrentTPS()` - Get current server TPS - `double getCurrentMSPT()` - Get current MSPT - `boolean isPlayerSuspicious(UUID playerUUID)` - Check if player flagged - Enables third-party plugin integration - Future: Additional methods for detailed performance data ### 🐛 Critical Bug Fixes #### DatabaseManager Exception Handling - **FIXED**: Added missing stack traces to SQL exceptions - **IMPROVED**: Now logs failed SQL statements for debugging - **ADDED**: JavaDoc documentation for `run()` method - Better error messages for database initialization failures - Prevents silent failures during schema creation #### XRayDetector Map Size Enforcement - **FIXED**: Unbounded memory growth in `playerOreMines` and `playerStoneMines` - **ADDED**: Hard limit of 5,000 player entries per map - **IMPROVED**: Cleanup task now removes empty `playerStoneMines` entries - Warning logs when size limit is exceeded - Debug output shows current map sizes #### Config.yml Language Consistency - **FIXED**: All comments now in English (was mixed German/English) - Consistent with multi-language support design - User-facing messages still use language files (en.yml/de.yml) - Better for international plugin distribution ### 🔧 Code Quality Improvements - **Consistent Error Handling** - All exceptions logged with stack traces - **English Logging** - All console logs in English (user-facing messages use i18n) - **Null Safety** - Extensive null checks before operations - **Improved Documentation** - JavaDoc added to critical methods - **Code Comments** - All config comments translated to English ### 📦 New Files Created - `util/Constants.java` - Centralized constants - `commands/CommandRegistry.java` - Modular command registration - `config/ConfigMigrator.java` - Config migration logic - `config/AsyncConfigSaver.java` - Async config saves - `db/FallbackLogger.java` - Fallback file logging - `db/TimeUnit.java` - SQL-safe time units - `api/PerformanceAPI.java` - Public API interface ### 🔧 Modified Files - `PerformanceAnalyzer.java` - CommandRegistry integration, version update to 2.2.0 - `DatabaseManager.java` - **CRITICAL FIX**: Stack traces, SQL logging, FallbackLogger, TimeUnit enum, failure detection - `AsyncConfigSaver.java` - **CRITICAL FIX**: Thread-safety with Bukkit Scheduler - `PluginConfig.java` - AsyncConfigSaver, ConfigMigrator, fallback config methods - `DiscordWebhook.java` - URL validation, SSRF protection - `MovementChecker.java` - Constants usage, event sampling - `XRayDetector.java` - **CRITICAL FIX**: Size limits (5000 players), improved cleanup, memory leak prevention - `Constants.java` - **NEW**: `XRAY_MAX_PLAYER_ENTRIES` constant - `config.yml` - **FIXED**: All comments translated to English - `pom.xml` - Version 2.2.0 ### ⚠️ Breaking Changes **None** - This release is fully backward compatible with v2.1.0. - All new features have sensible defaults - Existing configs auto-migrate - No database schema changes - No API changes to existing methods ### 📊 Configuration Changes **New Config Sections:** ```yaml # Graceful Degradation fallback_logging: enabled: true file: "plugins/PerformanceAnalyzer/fallback.log" ``` **Auto-Migration:** - Config auto-migrates from v5 to v5 (no version bump needed) - New `fallback_logging` section added automatically - Existing settings preserved ### 🔄 Migration Guide (from v2.1.0) 1. **Backup** - Backup your `plugins/PerformanceAnalyzer/` folder 2. **Stop Server** - Stop your server 3. **Replace JAR** - Replace old JAR with `PerformanceAnalyzer-2.2.0.jar` 4. **Start Server** - Start your server 5. **Auto-Migration** - Config auto-updates (check console for "Config migrated") 6. **Verify** - Run `/perfstatus` to ensure plugin loaded correctly **Optional Post-Migration:** - Review fallback logging settings in `config.yml` - Check `fallback.log` file (created only on database failure) ### 📈 Performance Impact - **CPU Usage**: Reduced ~90% for movement checks (event sampling) - **Memory Usage**: Lower (cleanup routines, size limits) - **Disk I/O**: Reduced (async config saves, fallback only on failure) - **Database Load**: Reduced (batching, indexing) - **Startup Time**: Unchanged ### 🐛 Known Issues **None** - All known issues from v2.1.0 have been resolved, including: - ✅ AsyncConfigSaver thread-safety violation (ConcurrentModificationException) - ✅ DatabaseManager silent failures (missing stack traces) - ✅ XRayDetector unbounded memory growth (5000+ players) - ✅ Config.yml mixed language comments (now all English) ---

### v2.0.0 (18.02.2025) - Major Release **Why Version 2.0?** This release fundamentally transforms PerformanceAnalyzer from a simple monitoring tool into an **intelligent lag diagnosis system**. With 4 new classes, a completely redesigned GUI, and groundbreaking lag source detection, this is more than just new features—it's a new generation of the plugin. **Major New Features**: - **🎯 Lag Source Detection** - Automatically identifies what's causing lag - **Player Activity Tracking** - Monitors player actions (blocks, movements, commands, interactions) - **Plugin Performance Analysis** - Identifies suspect plugins by event listeners and task count - **Integrated with Performance Drops** - Lag sources are shown in `/perfdrops` reports - Shows top 5 most active players during performance drops - Shows top 5 suspect plugins with risk scores - Weighted activity scoring (breaking blocks = higher weight than walking) - Detects "heavy" plugins (WorldEdit, FAWE, CoreProtect, etc.) - **🚨 Restricted World Zones** - Instant alerts for specific worlds - Configure worlds as "restricted zones" for mining monitoring - Option to monitor specific ores or all ores in restricted worlds - **Instant alerts** when players mine ores in restricted zones (no threshold needed) - Perfect for protecting areas or catching suspicious behavior - New config: `anticheat.restricted_worlds` and `anticheat.restricted_world_ores` - Logs to database with type `anticheat_restricted_zone` **Critical Bugfixes**: - ✅ Fixed missing imports in `PerformanceAnalyzer.java` (Player, UUID) - ✅ Fixed MySQL incompatibility - `AUTOINCREMENT` vs `AUTO_INCREMENT` - ✅ Fixed MySQL datetime syntax - All time-based queries now work with MySQL - `getRecentMspt()` - Fixed - `getAverageByType()` - Fixed - `countPerformanceSpikes()` - Fixed - `cleanOldData()` - Fixed - ✅ Plugin now fully compatible with both SQLite AND MySQL **Improvements**: - **🔧 Configurable Performance Thresholds** - All lag detection thresholds are now customizable - Chunk thresholds: tile entities, redstone, entities (warning/critical) - World health thresholds: entity warning/critical levels - Plugin risk score interpretation: low/medium/high boundaries - Prevents false positives on servers with different hardware - Config includes recommendations for standard/powerful/weak servers - Allows fine-tuning based on your specific server needs - Movement detection now properly distinguishes between walking and sprinting - XRay detector properly handles ore blocks (not items) - Better null-safety in configuration migration - Improved performance drop reports with lag source attribution - Version compatibility updated: **Paper 1.21.x** (all 1.21 versions) **🔥 Performance Optimizations**: - **Movement Sampling** - PlayerMove events only processed every 10th occurrence or >2 blocks distance (~90% reduction) - **Chunk Analysis Timeout** - Configurable timeout (default 5s) prevents long-running chunk scans - **Self-Monitoring** - Plugin measures and warns about its own performance impact - **Config Options** - All lag analysis features can be disabled independently - **Memory Cleanup** - Automatic cleanup on player quit prevents memory leaks - **New Config Section**: `lag_analysis` with `player_tracking`, `plugin_analysis`, `chunk_analysis_timeout_ms` **🎨 GUI Improvements**: - **🆕 Lag-Analyse GUI Page** - Interactive page showing active players and suspect plugins - Top 5 most active players with detailed breakdown - Top 5 suspect plugins with risk scores - Refresh and clear data buttons - Config-aware (shows warnings if features disabled) - **🆕 Performance Drops GUI Page** - Browse and click drops for detailed reports - Visual list of 21 recent drops - Color-coded by severity (Red/Orange/Yellow) - Click any drop for full report in chat - Shows lag source previews - **Expanded Main GUI** - Now 2 rows of features instead of 1 - Database Info button - World Stats quick-link - Better organization - **Multi-page Navigation** - Consistent back buttons between pages **New Classes**: - `PlayerActivityTracker` - Monitors player actions in real-time (with sampling) - `PluginTimingsAnalyzer` - Analyzes plugin performance impact - `LagAnalysisGUI` - GUI page for lag source inspection - `PerformanceDropsGUI` - GUI page for drop history browsing

### v1.2.6 (Current) **New Features**: - **Performance Drop Analysis** (`/perfdrops`) - Automatic detection and detailed analysis of performance drops - Automatically detects TPS drops (>5 TPS or below threshold) - Automatically detects MSPT spikes (>30ms or above threshold) - Records detailed server state at time of drop (chunks, entities, players, memory) - Shows top entity types per world during the drop - Displays all player locations during the drop - Stores last 20 drops for analysis - Logs drops to database for historical tracking - Detailed reports help quickly identify lag causes - **Configurable XRay Stone-to-Ore Ratio** - The ore-to-stone ratio threshold is now adjustable in config - New config option: `anticheat.xray_stone_ore_ratio` (default: 0.10) - Allows fine-tuning of XRay detection sensitivity - Alert messages now show the configured threshold **Improvements**: - Performance monitoring is now more proactive with automatic drop detection - XRay detection is more flexible with configurable ratio threshold - Better debugging capabilities for lag investigation

### v1.2.5 **New Features**: - **Per-World Statistics** (`/worldstats`) - Comprehensive per-world analysis - Entity counts, player counts, loaded chunks - Tile entity tracking - Entity density per chunk - Top entity types breakdown - Entity hotspots detection - **Entity Analysis** (`/entitystats`) - Server-wide entity distribution analysis - Category breakdown (Hostile, Passive, Items, Vehicles, etc.) - Top entity types - Hotspot detection with severity levels (Warning/Critical) - Per-world health status - **Chunk Tracking** (`/chunkstats`) - Chunk loading monitoring - Load/unload event tracking - Force-loaded chunk monitoring - New chunk generation counting - Problematic chunk detection (high entity/tile count) - Chunk thrashing detection (frequent load/unload cycles)

### v1.2.4 **New Features**: - **Spark Integration** - Full integration with the Spark profiler plugin - Accurate TPS from Spark (10s, 1m, 5m windows) - Precise MSPT measurements (avg, p95, max) - CPU usage monitoring (system and process) - Automatic fallback if Spark not installed - **Movement Type Detection** - AntiCheat now detects what type of movement the player is using - Walking, Sprinting, Sneaking, Swimming, Climbing - Vehicle detection: Horses, Pigs, Striders, Boats, Minecarts - Flight modes: Elytra, Riptide, Creative Flight - **Movement Alerts Command** (`/movealerts`) - Bundled alerts for Speed/Fly/Teleport violations - **Configurable Speed Thresholds** - Set thresholds for walk, sprint, fly, vertical, teleport - **Consecutive Violation System** - Reduces false positives by requiring multiple violations - **TPS Drop Threshold** - Configurable threshold for TPS drop warnings **Improvements**: - `/perfstatus` now shows enhanced data when Spark is available - Movement checks now automatically bypass legitimate movement types (vehicles, elytra, etc.) - Speed potion effects are now considered in speed calculations - Soul Speed enchantment bonus is accounted for on soul sand/soil - Movement alerts bundled like XRay alerts (less chat spam) - Discord notifications for movement violations

## Changelog ### v1.2.3 **New Features**: - **Multi-Language Support** - Full English and German translations - **Language Files** - Customizable `en.yml` and `de.yml` in `lang/` folder - **Hot-Reload Language** - Change language via config and `/perfreload` - **AntiCheat Hot-Reload** - Enable/disable AntiCheat via `/perfreload` without restart **Improvements**: - All user-facing messages now use the language system - Config automatically migrates with new `language` setting - Cleaner code structure with centralized translations

# PerformanceAnalyzer v1.2.2 (Paper 1.21.4-1.21.10 / Java 21) A comprehensive performance monitoring plugin for Minecraft Paper servers with database logging, alert system, interactive GUI, and AntiCheat functionality. ## Features ### Performance Monitoring - **TPS Tracking**: Approximate ticks per second - **MSPT Analysis**: Average, P95 percentile, and historical data - **Heap Monitoring**: Memory usage in percent - **Thread-Safe Sampling**: Reliable data collection without race conditions ### Database Support - **SQLite** (Default): No external DB required, perfect for small servers - **MySQL**: For larger servers with centralized database - **HikariCP Connection Pooling**: Optimal performance - **Async Batch Writes**: No performance impact from DB writes - **Historical Queries**: Retrieve performance data over time ranges ### Alert System - **Automatic Notifications** when thresholds are exceeded - **Admin Notifications**: In-game messages + console logs - **Cooldown System**: Prevents alert spam (5 minutes per type) - Alert types: - High MSPT (> 50ms) - TPS drops (< 19 TPS) - Heap usage (> 80%) - Packet flood (> 1000 packets/tick) ### ProtocolLib Integration - **Packet Analysis**: Counts received/sent packets - **Flood Detection**: Warns on unusually high packet load - **DB Logging**: Stores packet statistics for analysis - **1.21.x Compatible**: Automatically filters only supported packet types ### AntiCheat Module (BETA) - **Movement Checks**: Detects impossible movements - **Fly Detection**: Checks for illegal vertical movement - **Speed Detection**: Detects too fast horizontal movement - **XRay Detection**: Analyzes mining patterns for rare ores - Frequency analysis (too many ores in short time) - Ore/stone ratio (unnaturally high ore percentage) - Rare ore tracking (diamonds, emeralds, ancient debris) - **Per-ore thresholds**: Different thresholds for each ore type - **Ore exclusions**: Exclude specific ores from detection - **Bundled alerts**: Only one summary in chat, details via command - **Coordinates & World**: Shows where mining occurred (Multiverse compatible) - **Whitelist System**: Exclude players and LuckPerms groups - **Violation Tracking**: Counts violations per player - **Admin Alerts**: Notifies admins of suspicious behavior **NOTE**: The AntiCheat module is experimental and may produce false positives. For production servers, we recommend specialized plugins like Matrix, Vulcan, or Spartan. ### Interactive GUI System - **Performance Dashboard**: Live TPS, MSPT, and heap usage with updates - **Config GUI**: Toggle all settings (AntiCheat, XRay, Discord, packets) - **AntiCheat GUI**: Status overview, whitelist info, XRay settings - All options **changeable via GUI or command** - Intuitive operation with colored items ### Discord Webhook Integration - **Automatic Notifications** for critical events - **Color-coded Embeds** for different alert types - **Configurable Alerts**: Choose which events to report - **XRay Alerts**: Suspicious players reported to Discord - **Async HTTP Requests**: No performance impact - Simple setup via config ### LuckPerms Integration - **Group-based Whitelist** for AntiCheat - Automatic group detection - Primary & inherited groups are considered ## Commands ### `/perfstatus` Shows live performance data: - TPS (approximate) - MSPT (average and P95) - Heap usage in percent - Title warning on high load (for players) **Permission**: `performance.status` (Default: true) ### `/perfhistory [minutes]` Shows historical performance data as ASCII sparkline: - MSPT history from database (real data!) - Live statistics - DB average over selected time range - Number of performance spikes - Optional: Specify time range in minutes (Default: 60) **Permission**: `performance.history` (Default: true) Examples: - `/perfhistory` - Last 60 minutes - `/perfhistory 180` - Last 3 hours - `/perfhistory 1440` - Last 24 hours ### `/perfgui` Opens the interactive performance GUI: - Performance dashboard with live data - Change config settings with clicks - AntiCheat status and whitelist - Reload button for config **Permission**: `performance.gui` (Default: true) ### `/perfreload` Reloads the plugin configuration without server restart: - Config file is re-read - All settings are updated - XRay ore exclusions are reloaded - No interruption of operation **Permission**: `performance.admin` (Default: op) ### `/acwhitelist` (Alias: `/acwl`) Manages the AntiCheat whitelist: - `/acwhitelist add <player>` - Add player to whitelist - `/acwhitelist add group:<groupname>` - Add LuckPerms group - `/acwhitelist remove <player>` - Remove player from whitelist - `/acwhitelist remove group:<groupname>` - Remove group - `/acwhitelist list` - Show all whitelisted players/groups **Permission**: `performance.anticheat.manage` (Default: op) **Examples**: ```bash # Individual players /acwhitelist add Notch /acwhitelist remove Notch # LuckPerms groups /acwhitelist add group:admin /acwhitelist add group:moderator /acwhitelist remove group:builder # Show list /acwhitelist list ``` ### `/xrayalerts` (Alias: `/xra`) Shows and manages XRay suspicion alerts: - `/xrayalerts` - Show all suspicious players - `/xrayalerts <player>` - Details for a player (incl. which ores were mined) - `/xrayalerts clear <player>` - Clear alerts for a player - `/xrayalerts clearall` - Clear all alerts **Permission**: `performance.admin` (Default: op) **How it works**: - Alerts are collected and bundled - Only one summary appears in chat per player (every 5 min) - Details via `/xrayalerts <player>` (also shows exactly which ores were mined) - Alerts are automatically deleted after 30 minutes - Suspicious players are also reported to Discord (incl. ore breakdown) ### `/xrayores` (Alias: `/xro`) Manages XRay ore exclusions: - `/xrayores list` - Show excluded ores - `/xrayores available` - Show all available ores - `/xrayores add <ore>` - Exclude ore from XRay detection - `/xrayores remove <ore>` - Track ore again **Permission**: `performance.anticheat.manage` (Default: op) **Examples**: ```bash # Exclude coal and iron /xrayores add COAL_ORE /xrayores add IRON_ORE # Show available ores /xrayores available # Track ore again /xrayores remove COAL_ORE ``` ## Configuration ```yaml database: type: sqlite # or 'mysql' sqlite_file: "plugins/PerformanceAnalyzer/perf.db" performance: log_interval_seconds: 60 # Logging interval packet_analysis: true # ProtocolLib hook anticheat_enabled: false # AntiCheat module (BETA, default: off) debug_mode: false # Debug output in console anticheat: xray_detection: true # XRay detection xray_timewindow_seconds: 60 # Time window ops_bypass: false # Should OPs bypass AntiCheat? (default: false) xray_excluded_ores: [] # Exclude ores, e.g. ["COAL_ORE", "IRON_ORE"] xray_thresholds: # Per-ore thresholds coal: 20 iron: 15 copper: 15 gold: 10 redstone: 10 lapis: 8 diamond: 6 emerald: 4 ancient_debris: 3 whitelist_players: [] # Player UUIDs whitelist_groups: [] # LuckPerms groups thresholds: mspt: 50.0 # MSPT warning threshold heap_usage_percent: 80.0 # Heap warning threshold packet_flood_per_tick: 1000.0 # Packet flood threshold discord: enabled: false # Discord notifications webhook_url: "" # Discord Webhook URL alert_types: # Which alerts to send? high_mspt: true tps_drop: true high_heap: true packet_flood: true anticheat: true # XRay alerts ``` ### XRay Ore Exclusions You can exclude specific ores from XRay detection: ```yaml anticheat: xray_excluded_ores: - COAL_ORE # Exclude coal - IRON_ORE # Exclude iron - COPPER_ORE # Exclude copper ``` Available ores: `COAL_ORE`, `IRON_ORE`, `COPPER_ORE`, `GOLD_ORE`, `REDSTONE_ORE`, `LAPIS_ORE`, `DIAMOND_ORE`, `EMERALD_ORE`, `ANCIENT_DEBRIS` Deepslate variants (e.g. `DEEPSLATE_DIAMOND_ORE`) are automatically excluded as well. ### Per-Ore Thresholds Each ore type has its own threshold. When a player mines more than the threshold amount within the time window, an alert is triggered: ```yaml anticheat: xray_thresholds: coal: 20 # Common - high threshold iron: 15 copper: 15 gold: 10 redstone: 10 lapis: 8 diamond: 6 # Rare - low threshold emerald: 4 ancient_debris: 3 # Very rare - very low threshold ``` ## Permissions | Permission | Description | Default | |------------|-------------|---------| | `performance.status` | Use `/perfstatus` | true | | `performance.history` | Use `/perfhistory` | true | | `performance.gui` | Use `/perfgui` | true | | `performance.admin` | `/perfreload`, `/xrayalerts`, alert notifications | op | | `performance.anticheat.bypass` | Bypass all AntiCheat checks | false | | `performance.anticheat.manage` | Use `/acwhitelist`, `/xrayores` | op | ## Optional Dependencies ### ProtocolLib (recommended) - Enables packet analysis and flood detection - Download: https://www.spigotmc.org/resources/protocollib.1997/ ### LuckPerms (recommended) - Enables group-based AntiCheat whitelist - Automatic group detection for players - Download: https://luckperms.net/ ### spark (planned) - Future integration for detailed profiling - Download: https://spark.lucko.me/ ## Technical Details - **Java 21** required - **Paper 1.21.4-1.21.10** compatible - Thread-safe implementation - Minimal performance overhead - Async DB operations - Maven Shade Plugin for dependency shading ## Changelog ### v1.2.2 (Current) **New Features**: - **Per-Ore Thresholds** - Each ore has its own threshold (Ancient Debris: 3, Diamond: 6, Coal: 20, etc.) - **Coordinates in XRay Alerts** - Shows world, position, and mining area (Multiverse compatible) - **Debug Mode** - Console logs only when `debug_mode` enabled in config.yml - **OPs Bypass Option** - Configurable whether OPs should bypass AntiCheat checks **Improvements**: - MySQL driver as `provided` - Server operator must supply the driver - Clear error message when MySQL configured but driver missing - Dynamic User-Agent in Discord Webhook (shows current plugin version) - AntiCheat disabled by default (must be consciously enabled) - Less console spam through debug mode **Bugfixes**: - TPS drop alerts are now correctly sent to Discord - XRay commands work even when AntiCheat is disabled (shows helpful message) ### v1.2.1 **New Features**: - **XRay Alert System** (`/xrayalerts`) - Bundled alerts with command overview - **XRay Ore Exclusions** (`/xrayores`) - Exclude ores via command - **XRay Ore Breakdown** - Shows exactly which ores were mined - **XRay Discord Integration** - Suspicious players reported to Discord - **Config Migration** - New config entries are automatically added **Improvements**: - ProtocolLib 1.21.x compatibility (no more warnings) - GUI completely overhauled and fixed - Bundled chat notifications (less spam) - Extended config options for XRay - Ore breakdown in alerts and Discord messages **Bugfixes**: - GUI event handlers now work correctly - ProtocolLib filters only supported packet types - Thread-safety improvements in XRayDetector - Config is automatically updated on plugin updates ### v1.2.0 **New Features**: - **Interactive GUI System** (`/perfgui`) with dashboard, config, and AntiCheat overview - **XRay Detection** with three detection methods (frequency, ratio, rare ores) - **Discord Webhook Integration** for automatic notifications - **LuckPerms Integration** for group-based AntiCheat whitelist - **Whitelist System** with `/acwhitelist` command (players + groups) - **Reload Command** (`/perfreload`) for config updates without restart - **Tab Completion** for all commands **Improvements**: - Alert system with Discord integration - Config options changeable via GUI - Extended AntiCheat config - All settings live-reloadable ### v1.1.0 **Fixed**: - Fake data in AsciiSparkline replaced with real DB data - Thread-safety issues in TickSampler - ProtocolLib hook fully implemented - Old duplicate classes removed **New**: - Alert system with admin notifications - AntiCheat module for basic cheat detection - DB query methods for historical analysis - Automatic DB logging for all metrics - Packet flood detection - Performance spike counter - Extended config options ## Future Features (TODO) - [ ] Web dashboard for live monitoring - [ ] Grafana/Prometheus export - [ ] Per-world performance stats - [ ] Chunk loading tracking - [ ] Entity density analysis - [ ] Spark integration for profiling - [x] ~~Discord webhook for alerts~~ (Implemented) - [ ] Database cleanup command