395 lines
22 KiB
Python
395 lines
22 KiB
Python
import json
|
|
import os
|
|
import re
|
|
import time
|
|
from os import listdir
|
|
from os.path import isfile, join
|
|
|
|
import nbt
|
|
import requests
|
|
import schedule
|
|
from mcrcon import MCRcon, MCRconException
|
|
from prometheus_client import Metric, REGISTRY, start_http_server
|
|
|
|
|
|
class MinecraftCollector(object):
|
|
def __init__(self):
|
|
self.stats_directory = "/world/stats"
|
|
self.player_directory = "/world/playerdata"
|
|
self.advancements_directory = "/world/advancements"
|
|
self.better_questing = "/world/betterquesting"
|
|
self.player_map = dict()
|
|
self.quests_enabled = False
|
|
|
|
self.rcon = None
|
|
self.rcon_connected = False
|
|
if all(x in os.environ for x in ['RCON_HOST', 'RCON_PASSWORD']):
|
|
self.rcon = MCRcon(os.environ['RCON_HOST'], os.environ['RCON_PASSWORD'], port=int(os.environ['RCON_PORT']))
|
|
print("RCON is enabled for " + os.environ['RCON_HOST'])
|
|
|
|
if os.path.isdir(self.better_questing):
|
|
self.quests_enabled = True
|
|
|
|
schedule.every().day.at("01:00").do(self.flush_playernamecache)
|
|
|
|
def get_players(self):
|
|
return [f[:-5] for f in listdir(self.stats_directory) if isfile(join(self.stats_directory, f))]
|
|
|
|
def flush_playernamecache(self):
|
|
print("flushing playername cache")
|
|
self.player_map = dict()
|
|
|
|
def uuid_to_player(self, uuid):
|
|
if uuid in self.player_map:
|
|
return self.player_map[uuid]
|
|
else:
|
|
try:
|
|
result = requests.get('https://sessionserver.mojang.com/session/minecraft/profile/' + uuid)
|
|
self.player_map[uuid] = result.json()['name']
|
|
return (result.json()['name'])
|
|
except:
|
|
return
|
|
|
|
def rcon_connect(self):
|
|
try:
|
|
self.rcon.connect()
|
|
self.rcon_connected = True
|
|
print("Successfully connected to RCON")
|
|
return True
|
|
except Exception as e:
|
|
print("Failed to connect to RCON")
|
|
print(e)
|
|
return False
|
|
|
|
def rcon_disconnect(self):
|
|
self.rcon.disconnect()
|
|
self.rcon_connected = False
|
|
|
|
def rcon_command(self, command):
|
|
try:
|
|
response = self.rcon.command(command)
|
|
except MCRconException as e:
|
|
response = None
|
|
if e == "Connection timeout error":
|
|
print("Lost RCON Connection")
|
|
self.rcon_disconnect()
|
|
else:
|
|
print("RCON command failed")
|
|
except (ConnectionResetError, ConnectionAbortedError, BrokenPipeError):
|
|
print("Lost RCON Connection")
|
|
self.rcon_disconnect()
|
|
response = None
|
|
|
|
return response
|
|
|
|
def get_server_stats(self):
|
|
if self.rcon is None or (not self.rcon_connected and not self.rcon_connect()):
|
|
return []
|
|
|
|
metrics = []
|
|
|
|
dim_tps = Metric('mc_dim_tps', 'TPS of a dimension', "counter")
|
|
dim_ticktime = Metric('mc_dim_ticktime', "Time a Tick took in a Dimension", "counter")
|
|
overall_tps = Metric('mc_overall_tps', 'overall TPS', "counter")
|
|
overall_ticktime = Metric('mc_overall_ticktime', "overall Ticktime", "counter")
|
|
player_online = Metric('mc_player_online', "is 1 if player is online", "counter")
|
|
entities = Metric('mc_entities', "type and count of active entites", "counter")
|
|
tps_1m = Metric('mc_paper_tps_1m', '1 Minute TPS', "counter")
|
|
tps_5m = Metric('mc_paper_tps_5m', '5 Minute TPS', "counter")
|
|
tps_15m = Metric('mc_paper_tps_15m', '15 Minute TPS', "counter")
|
|
|
|
metrics.extend(
|
|
[dim_tps, dim_ticktime, overall_tps, overall_ticktime, player_online, entities, tps_1m, tps_5m, tps_15m])
|
|
if 'PAPER_SERVER' in os.environ and os.environ['PAPER_SERVER'] == "True":
|
|
resp = str(self.rcon_command("tps")).strip().replace("§a", "")
|
|
tpsregex = re.compile("TPS from last 1m, 5m, 15m: (\d*\.\d*), (\d*\.\d*), (\d*\.\d*)")
|
|
for m1, m5, m15 in tpsregex.findall(resp):
|
|
tps_1m.add_sample('mc_paper_tps_1m', value=m1, labels={'tps': '1m'})
|
|
tps_5m.add_sample('mc_paper_tps_5m', value=m5, labels={'tps': '5m'})
|
|
tps_15m.add_sample('mc_paper_tps_15m', value=m15, labels={'tps': '15m'})
|
|
if 'FORGE_SERVER' in os.environ and os.environ['FORGE_SERVER'] == "True":
|
|
# dimensions
|
|
resp = self.rcon_command("forge tps")
|
|
dimtpsregex = re.compile("Dim\s*(-*\d*)\s\((.*?)\)\s:\sMean tick time:\s(.*?) ms\. Mean TPS: (\d*\.\d*)")
|
|
for dimid, dimname, meanticktime, meantps in dimtpsregex.findall(resp):
|
|
dim_tps.add_sample('mc_dim_tps', value=meantps, labels={'dimension_id': dimid, 'dimension_name': dimname})
|
|
dim_ticktime.add_sample('mc_dim_ticktime', value=meanticktime,
|
|
labels={'dimension_id': dimid, 'dimension_name': dimname})
|
|
overallregex = re.compile("Overall\s?: Mean tick time: (.*) ms. Mean TPS: (.*)")
|
|
overall_tps.add_sample('mc_overall_tps', value=overallregex.findall(resp)[0][1], labels={})
|
|
overall_ticktime.add_sample('mc_overall_ticktime', value=overallregex.findall(resp)[0][0], labels={})
|
|
|
|
# entites
|
|
resp = self.rcon_command("forge entity list")
|
|
entityregex = re.compile("(\d+): (.*?:.*?)\s")
|
|
for entitycount, entityname in entityregex.findall(resp):
|
|
entities.add_sample('mc_entities', value=entitycount, labels={'entity': entityname})
|
|
|
|
# dynmap
|
|
if 'DYNMAP_ENABLED' in os.environ and os.environ['DYNMAP_ENABLED'] == "True":
|
|
dynmap_tile_render_statistics = Metric('mc_dynmap_tile_render_statistics',
|
|
'Tile Render Statistics reported by Dynmap', "counter")
|
|
dynmap_chunk_loading_statistics_count = Metric('mc_dynmap_chunk_loading_statistics_count',
|
|
'Chunk Loading Statistics reported by Dynmap', "counter")
|
|
dynmap_chunk_loading_statistics_duration = Metric('mc_dynmap_chunk_loading_statistics_duration',
|
|
'Chunk Loading Statistics reported by Dynmap', "counter")
|
|
metrics.extend([dynmap_tile_render_statistics, dynmap_chunk_loading_statistics_count,
|
|
dynmap_chunk_loading_statistics_duration])
|
|
|
|
resp = self.rcon_command("dynmap stats")
|
|
|
|
dynmaptilerenderregex = re.compile(" (.*?): processed=(\d*), rendered=(\d*), updated=(\d*)")
|
|
for dim, processed, rendered, updated in dynmaptilerenderregex.findall(resp):
|
|
dynmap_tile_render_statistics.add_sample('mc_dynmap_tile_render_statistics', value=processed,
|
|
labels={'type': 'processed', 'file': dim})
|
|
dynmap_tile_render_statistics.add_sample('mc_dynmap_tile_render_statistics', value=rendered,
|
|
labels={'type': 'rendered', 'file': dim})
|
|
dynmap_tile_render_statistics.add_sample('mc_dynmap_tile_render_statistics', value=updated,
|
|
labels={'type': 'updated', 'file': dim})
|
|
|
|
dynmapchunkloadingregex = re.compile("Chunks processed: (.*?): count=(\d*), (\d*.\d*)")
|
|
for state, count, duration_per_chunk in dynmapchunkloadingregex.findall(resp):
|
|
dynmap_chunk_loading_statistics_count.add_sample('mc_dynmap_chunk_loading_statistics', value=count,
|
|
labels={'type': state})
|
|
dynmap_chunk_loading_statistics_duration.add_sample('mc_dynmap_chunk_loading_duration',
|
|
value=duration_per_chunk, labels={'type': state})
|
|
|
|
# player
|
|
resp = self.rcon_command("list")
|
|
#playerregex = re.compile("players online:(.*)")
|
|
#if playerregex.findall(resp):
|
|
# for player in playerregex.findall(resp)[0].split(","):
|
|
# if not player.isspace():
|
|
# player_online.add_sample('mc_player_online', value=1, labels={'player': player.lstrip()})
|
|
if resp.startswith('There are 0 '):
|
|
player_online.add_sample('mc_player_online', value=0, labels={})
|
|
else:
|
|
players = resp.split(':')[1].replace(' ','').split(',')
|
|
for player in players:
|
|
player_online.add_sample('mc_player_online', value=1, labels={'player': player})
|
|
return metrics
|
|
|
|
def get_player_quests_finished(self, uuid):
|
|
with open(self.better_questing + "/QuestProgress.json") as json_file:
|
|
data = json.load(json_file)
|
|
json_file.close()
|
|
counter = 0
|
|
for _, value in data['questProgress:9'].items():
|
|
for _, u in value['tasks:9']['0:10']['completeUsers:9'].items():
|
|
if u == uuid:
|
|
counter += 1
|
|
return counter
|
|
|
|
def get_player_stats(self, uuid):
|
|
with open(self.stats_directory + "/" + uuid + ".json") as json_file:
|
|
data = json.load(json_file)
|
|
json_file.close()
|
|
nbtfile = nbt.nbt.NBTFile(self.player_directory + "/" + uuid + ".dat", 'rb')
|
|
data["stat.XpTotal"] = nbtfile.get("XpTotal").value
|
|
data["stat.XpLevel"] = nbtfile.get("XpLevel").value
|
|
data["stat.Score"] = nbtfile.get("Score").value
|
|
data["stat.Health"] = nbtfile.get("Health").value
|
|
data["stat.foodLevel"] = nbtfile.get("foodLevel").value
|
|
with open(self.advancements_directory + "/" + uuid + ".json") as json_file:
|
|
count = 0
|
|
advancements = json.load(json_file)
|
|
for key, value in advancements.items():
|
|
if key in ("DataVersion"):
|
|
continue
|
|
if value["done"] == True:
|
|
count += 1
|
|
data["stat.advancements"] = count
|
|
if self.quests_enabled:
|
|
data["stat.questsFinished"] = self.get_player_quests_finished(uuid)
|
|
return data
|
|
|
|
def update_metrics_for_player(self, uuid):
|
|
name = self.uuid_to_player(uuid)
|
|
if not name:
|
|
return
|
|
|
|
data = self.get_player_stats(uuid)
|
|
|
|
blocks_mined = Metric('mc_blocks_mined', 'Blocks a Player mined', "counter")
|
|
blocks_picked_up = Metric('mc_blocks_picked_up', 'Blocks a Player picked up', "counter")
|
|
player_deaths = Metric('mc_player_deaths', 'How often a Player died', "counter")
|
|
player_jumps = Metric('mc_player_jumps', 'How often a Player has jumped', "counter")
|
|
cm_traveled = Metric('mc_cm_traveled', 'How many cm a Player traveled, whatever that means', "counter")
|
|
player_xp_total = Metric('mc_player_xp_total', "How much total XP a player has", "counter")
|
|
player_current_level = Metric('mc_player_current_level', "How much current XP a player has", "counter")
|
|
player_food_level = Metric('mc_player_food_level', "How much food the player currently has", "counter")
|
|
player_health = Metric('mc_player_health', "How much Health the player currently has", "counter")
|
|
player_score = Metric('mc_player_score', "The Score of the player", "counter")
|
|
entities_killed = Metric('mc_entities_killed', "Entities killed by player", "counter")
|
|
damage_taken = Metric('mc_damage_taken', "Damage Taken by Player", "counter")
|
|
damage_dealt = Metric('mc_damage_dealt', "Damage dealt by Player", "counter")
|
|
blocks_crafted = Metric('mc_blocks_crafted', "Items a Player crafted", "counter")
|
|
player_playtime = Metric('mc_player_playtime', "Time in Minutes a Player was online", "counter")
|
|
player_advancements = Metric('mc_player_advancements', "Number of completed advances of a player", "counter")
|
|
player_slept = Metric('mc_player_slept', "Times a Player slept in a bed", "counter")
|
|
player_quests_finished = Metric('mc_player_quests_finished', 'Number of quests a Player has finished', 'counter')
|
|
player_used_crafting_table = Metric('mc_player_used_crafting_table', "Times a Player used a Crafting Table",
|
|
"counter")
|
|
mc_custom = Metric('mc_custom', "Custom Minecraft stat", "counter")
|
|
for key, value in data.items(): # pre 1.15
|
|
if key in ("stats", "DataVersion"):
|
|
continue
|
|
stat = key.split(".")[1] # entityKilledBy
|
|
if stat == "mineBlock":
|
|
blocks_mined.add_sample("blocks_mined", value=value, labels={'player': name, 'block': '.'.join(
|
|
(key.split(".")[2], key.split(".")[3]))})
|
|
elif stat == "pickup":
|
|
blocks_picked_up.add_sample("blocks_picked_up", value=value, labels={'player': name, 'block': '.'.join(
|
|
(key.split(".")[2], key.split(".")[3]))})
|
|
elif stat == "entityKilledBy":
|
|
if len(key.split(".")) == 4:
|
|
player_deaths.add_sample('mc_player_deaths', value=value, labels={'player': name, 'cause': '.'.join(
|
|
(key.split(".")[2], key.split(".")[3]))})
|
|
else:
|
|
player_deaths.add_sample('mc_player_deaths', value=value,
|
|
labels={'player': name, 'cause': key.split(".")[2]})
|
|
elif stat == "jump":
|
|
player_jumps.add_sample("player_jumps", value=value, labels={'player': name})
|
|
elif stat == "walkOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "walking"})
|
|
elif stat == "swimOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "swimming"})
|
|
elif stat == "sprintOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "sprinting"})
|
|
elif stat == "diveOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "diving"})
|
|
elif stat == "fallOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "falling"})
|
|
elif stat == "flyOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "flying"})
|
|
elif stat == "boatOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "boat"})
|
|
elif stat == "horseOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "horse"})
|
|
elif stat == "climbOneCm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "climbing"})
|
|
elif stat == "XpTotal":
|
|
player_xp_total.add_sample('mc_player_xp_total', value=value, labels={'player': name})
|
|
elif stat == "XpLevel":
|
|
player_current_level.add_sample('mc_player_current_level', value=value, labels={'player': name})
|
|
elif stat == "foodLevel":
|
|
player_food_level.add_sample('mc_player_food_level', value=value, labels={'player': name})
|
|
elif stat == "Health":
|
|
player_health.add_sample('mc_player_health', value=value, labels={'player': name})
|
|
elif stat == "Score":
|
|
player_score.add_sample('mc_player_score', value=value, labels={'player': name})
|
|
elif stat == "killEntity":
|
|
entities_killed.add_sample('mc_entities_killed', value=value,
|
|
labels={'player': name, "entity": key.split(".")[2]})
|
|
elif stat == "damageDealt":
|
|
damage_dealt.add_sample('mc_damage_dealt', value=value, labels={'player': name})
|
|
elif stat == "damageTaken":
|
|
damage_dealt.add_sample('mc_damage_taken', value=value, labels={'player': name})
|
|
elif stat == "craftItem":
|
|
blocks_crafted.add_sample('mc_blocks_crafted', value=value, labels={'player': name, 'block': '.'.join(
|
|
(key.split(".")[2], key.split(".")[3]))})
|
|
elif stat == "playOneMinute":
|
|
player_playtime.add_sample('mc_player_playtime', value=value, labels={'player': name})
|
|
elif stat == "advancements":
|
|
player_advancements.add_sample('mc_player_advancements', value=value, labels={'player': name})
|
|
elif stat == "sleepInBed":
|
|
player_slept.add_sample('mc_player_slept', value=value, labels={'player': name})
|
|
elif stat == "craftingTableInteraction":
|
|
player_used_crafting_table.add_sample('mc_player_used_crafting_table', value=value,
|
|
labels={'player': name})
|
|
elif stat == "questsFinished":
|
|
player_quests_finished.add_sample('mc_player_quests_finished', value=value, labels={'player': name})
|
|
|
|
if "stats" in data: # Minecraft > 1.15
|
|
if "minecraft:crafted" in data["stats"]:
|
|
for block, value in data["stats"]["minecraft:crafted"].items():
|
|
blocks_crafted.add_sample('mc_blocks_crafted', value=value, labels={'player': name, 'block': block})
|
|
if "minecraft:mined" in data["stats"]:
|
|
for block, value in data["stats"]["minecraft:mined"].items():
|
|
blocks_mined.add_sample("blocks_mined", value=value, labels={'player': name, 'block': block})
|
|
if "minecraft:picked_up" in data["stats"]:
|
|
for block, value in data["stats"]["minecraft:picked_up"].items():
|
|
blocks_picked_up.add_sample("blocks_picked_up", value=value,
|
|
labels={'player': name, 'block': block})
|
|
if "minecraft:killed" in data["stats"]:
|
|
for entity, value in data["stats"]["minecraft:killed"].items():
|
|
entities_killed.add_sample('mc_entities_killed', value=value,
|
|
labels={'player': name, "entity": entity})
|
|
if "minecraft:killed_by" in data["stats"]:
|
|
for entity, value in data["stats"]["minecraft:killed_by"].items():
|
|
player_deaths.add_sample('mc_player_deaths', value=value, labels={'player': name, 'cause': entity})
|
|
for stat, value in data["stats"]["minecraft:custom"].items():
|
|
if stat == "minecraft:jump":
|
|
player_jumps.add_sample("player_jumps", value=value, labels={'player': name})
|
|
elif stat == "minecraft:deaths":
|
|
player_deaths.add_sample('mc_player_deaths', value=value, labels={'player': name})
|
|
elif stat == "minecraft:damage_taken":
|
|
damage_taken.add_sample('mc_damage_taken', value=value, labels={'player': name})
|
|
elif stat == "minecraft:damage_dealt":
|
|
damage_dealt.add_sample('mc_damage_dealt',value=value,labels={'player':name})
|
|
elif stat == "minecraft:play_time":
|
|
player_playtime.add_sample('mc_player_playtime',value=value,labels={'player':name})
|
|
elif stat == "minecraft:play_one_minute": # pre 1.17
|
|
player_playtime.add_sample('mc_player_playtime',value=value,labels={'player':name})
|
|
elif stat == "minecraft:walk_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "walking"})
|
|
elif stat == "minecraft:walk_on_water_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "swimming"})
|
|
elif stat == "minecraft:sprint_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "sprinting"})
|
|
elif stat == "minecraft:walk_under_water_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "diving"})
|
|
elif stat == "minecraft:fall_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "falling"})
|
|
elif stat == "minecraft:fly_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "flying"})
|
|
elif stat == "minecraft:boat_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "boat"})
|
|
elif stat == "minecraft:horse_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "horse"})
|
|
elif stat == "minecraft:climb_one_cm":
|
|
cm_traveled.add_sample("cm_traveled", value=value, labels={'player': name, 'method': "climbing"})
|
|
elif stat == "minecraft:sleep_in_bed":
|
|
player_slept.add_sample('mc_player_slept', value=value, labels={'player': name})
|
|
elif stat == "minecraft:interact_with_crafting_table":
|
|
player_used_crafting_table.add_sample('mc_player_used_crafting_table', value=value,
|
|
labels={'player': name})
|
|
else:
|
|
mc_custom.add_sample('mc_custom', value=value, labels={'stat': stat})
|
|
return [blocks_mined, blocks_picked_up, player_deaths, player_jumps, cm_traveled, player_xp_total,
|
|
player_current_level, player_food_level, player_health, player_score, entities_killed, damage_taken,
|
|
damage_dealt, blocks_crafted, player_playtime, player_advancements, player_slept,
|
|
player_used_crafting_table, player_quests_finished, mc_custom]
|
|
|
|
def collect(self):
|
|
for player in self.get_players():
|
|
metrics = self.update_metrics_for_player(player)
|
|
if not metrics:
|
|
continue
|
|
|
|
for metric in metrics:
|
|
yield metric
|
|
|
|
for metric in self.get_server_stats():
|
|
yield metric
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
HTTP_PORT = int(os.environ.get('HTTP_PORT'))
|
|
except:
|
|
HTTP_PORT = 8000
|
|
|
|
start_http_server(HTTP_PORT)
|
|
REGISTRY.register(MinecraftCollector())
|
|
|
|
print(f'Exporter started on Port {HTTP_PORT}')
|
|
|
|
while True:
|
|
try:
|
|
time.sleep(1)
|
|
schedule.run_pending()
|
|
except MCRconException:
|
|
# RCON timeout
|
|
collector.rcon_disconnect()
|