com/hypixel/hytale/metrics/ExecutorMetricsRegistry.java
package com.hypixel.hytale.metrics;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.function.Function;
import javax.annotation.Nonnull;
import org.bson.BsonValue;
public class ExecutorMetricsRegistry<T extends ExecutorMetricsRegistry.ExecutorMetric> extends MetricsRegistry<T> {
public ExecutorMetricsRegistry() {
}
public BsonValue encode(@Nonnull T t, ExtraInfo extraInfo) {
return t.isInThread() ? super.encode(t, extraInfo) : (BsonValue)CompletableFuture.supplyAsync(() -> super.encode(t, extraInfo), t).join();
}
public <R extends MetricProvider> ExecutorMetricsRegistry<T> register(String id, @Nonnull Function<T, R> func) {
return (ExecutorMetricsRegistry)super.register(id, func);
}
public <R> ExecutorMetricsRegistry<T> register(String id, Function<T, R> func, Codec<R> codec) {
return (ExecutorMetricsRegistry)super.register(id, func, codec);
}
public ExecutorMetricsRegistry<T> register(String id, MetricsRegistry<Void> metricsRegistry) {
return (ExecutorMetricsRegistry)super.register(id, metricsRegistry);
}
public <R> ExecutorMetricsRegistry<T> register(String id, Function<T, R> func, Function<R, MetricsRegistry<R>> codecFunc) {
return (ExecutorMetricsRegistry)super.register(id, func, codecFunc);
}
public interface ExecutorMetric extends Executor {
boolean isInThread();
}
}
com/hypixel/hytale/metrics/InitStackThread.java
package com.hypixel.hytale.metrics;
public interface InitStackThread {
StackTraceElement[] getInitStack();
}
com/hypixel/hytale/metrics/JVMMetrics.java
package com.hypixel.hytale.metrics;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
import java.lang.management.ClassLoadingMXBean;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryManagerMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryType;
import java.lang.management.MemoryUsage;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.time.Duration;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
public class JVMMetrics {
@Nonnull
public static final MetricsRegistry<ClassLoader> CLASS_LOADER_METRICS_REGISTRY = new MetricsRegistry<ClassLoader>();
@Nonnull
public static final MetricsRegistry<MemoryUsage> MEMORY_USAGE_METRICS_REGISTRY;
@Nonnull
public MetricsRegistry<GarbageCollectorMXBean> GARBAGE_COLLECTOR_METRICS_REGISTRY;
MetricsRegistry<MemoryPoolMXBean> MEMORY_POOL_METRICS_REGISTRY;
MetricsRegistry<Void> METRICS_REGISTRY;
{
}
{
CLASS_LOADER_METRICS_REGISTRY.register(, ClassLoader::getName, Codec.STRING);
CLASS_LOADER_METRICS_REGISTRY.register(, ClassLoader::getParent, CLASS_LOADER_METRICS_REGISTRY);
MEMORY_USAGE_METRICS_REGISTRY = <MemoryUsage>();
MEMORY_USAGE_METRICS_REGISTRY.register(, MemoryUsage::getInit, Codec.LONG);
MEMORY_USAGE_METRICS_REGISTRY.register(, MemoryUsage::getUsed, Codec.LONG);
MEMORY_USAGE_METRICS_REGISTRY.register(, MemoryUsage::getCommitted, Codec.LONG);
MEMORY_USAGE_METRICS_REGISTRY.register(, MemoryUsage::getMax, Codec.LONG);
GARBAGE_COLLECTOR_METRICS_REGISTRY = <GarbageCollectorMXBean>();
GARBAGE_COLLECTOR_METRICS_REGISTRY.register(, MemoryManagerMXBean::getName, Codec.STRING);
GARBAGE_COLLECTOR_METRICS_REGISTRY.register(, MemoryManagerMXBean::getMemoryPoolNames, Codec.STRING_ARRAY);
GARBAGE_COLLECTOR_METRICS_REGISTRY.register(, GarbageCollectorMXBean::getCollectionCount, Codec.LONG);
GARBAGE_COLLECTOR_METRICS_REGISTRY.register(, GarbageCollectorMXBean::getCollectionTime, Codec.LONG);
MEMORY_POOL_METRICS_REGISTRY = <MemoryPoolMXBean>();
MEMORY_POOL_METRICS_REGISTRY.register(, MemoryPoolMXBean::getName, Codec.STRING);
MEMORY_POOL_METRICS_REGISTRY.register(, MemoryPoolMXBean::getType, (MemoryType.class));
MEMORY_POOL_METRICS_REGISTRY.register(, MemoryPoolMXBean::getPeakUsage, MEMORY_USAGE_METRICS_REGISTRY);
MEMORY_POOL_METRICS_REGISTRY.register(, MemoryPoolMXBean::getUsage, MEMORY_USAGE_METRICS_REGISTRY);
MEMORY_POOL_METRICS_REGISTRY.register(, MemoryPoolMXBean::getCollectionUsage, MEMORY_USAGE_METRICS_REGISTRY);
MetricsRegistry<MemoryPoolMXBean> usageThreshold = <MemoryPoolMXBean>();
usageThreshold.register(, MemoryPoolMXBean::getUsageThreshold, Codec.LONG);
usageThreshold.register(, MemoryPoolMXBean::getUsageThresholdCount, Codec.LONG);
usageThreshold.register(, MemoryPoolMXBean::isUsageThresholdExceeded, Codec.BOOLEAN);
MEMORY_POOL_METRICS_REGISTRY.register(, (memoryPoolMXBean) -> !memoryPoolMXBean.isUsageThresholdSupported() ? : memoryPoolMXBean, usageThreshold);
usageThreshold = <MemoryPoolMXBean>();
usageThreshold.register(, MemoryPoolMXBean::getCollectionUsageThreshold, Codec.LONG);
usageThreshold.register(, MemoryPoolMXBean::getCollectionUsageThresholdCount, Codec.LONG);
usageThreshold.register(, MemoryPoolMXBean::isCollectionUsageThresholdExceeded, Codec.BOOLEAN);
MEMORY_POOL_METRICS_REGISTRY.register(, (memoryPoolMXBean) -> !memoryPoolMXBean.isCollectionUsageThresholdSupported() ? : memoryPoolMXBean, usageThreshold);
METRICS_REGISTRY = <Void>();
usageThreshold = <MemoryPoolMXBean>();
METRICS_REGISTRY.register(, (unused) -> System.getenv(), Codec.STRING);
METRICS_REGISTRY.register(, (unused) -> System.getenv(), Codec.STRING);
METRICS_REGISTRY.register(, (unused) -> System.getenv(), Codec.STRING);
usageThreshold.register(, OperatingSystemMXBean::getName, Codec.STRING);
usageThreshold.register(, OperatingSystemMXBean::getArch, Codec.STRING);
usageThreshold.register(, OperatingSystemMXBean::getVersion, Codec.STRING);
usageThreshold.register(, (unused) -> Runtime.getRuntime().availableProcessors(), Codec.INTEGER);
usageThreshold.register(, OperatingSystemMXBean::getSystemLoadAverage, Codec.DOUBLE);
(ManagementFactory.getOperatingSystemMXBean() com.sun.management.OperatingSystemMXBean) {
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getCpuLoad(), Codec.DOUBLE);
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getProcessCpuLoad(), Codec.DOUBLE);
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getTotalMemorySize(), Codec.LONG);
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getFreeMemorySize(), Codec.LONG);
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getTotalSwapSpaceSize(), Codec.LONG);
usageThreshold.register(, (operatingSystemMXBean) -> ((com.sun.management.OperatingSystemMXBean)operatingSystemMXBean).getFreeSwapSpaceSize(), Codec.LONG);
}
METRICS_REGISTRY.register(, (aVoid) -> ManagementFactory.getOperatingSystemMXBean(), usageThreshold);
usageThreshold = <MemoryPoolMXBean>();
usageThreshold.register(, (runtimeMXBean) -> Instant.ofEpochMilli(runtimeMXBean.getStartTime()), Codec.INSTANT);
usageThreshold.register(, (runtimeMXBean) -> Duration.ofMillis(runtimeMXBean.getUptime()), Codec.DURATION);
usageThreshold.register(, RuntimeMXBean::getName, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getSpecName, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getSpecVendor, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getSpecVersion, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getManagementSpecVersion, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getVmName, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getVmVendor, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getVmVersion, Codec.STRING);
usageThreshold.register(, RuntimeMXBean::getLibraryPath, Codec.STRING);
{
ManagementFactory.getRuntimeMXBean().getBootClassPath();
usageThreshold.register(, RuntimeMXBean::getBootClassPath, Codec.STRING);
} (UnsupportedOperationException var2) {
}
usageThreshold.register(, RuntimeMXBean::getClassPath, Codec.STRING);
usageThreshold.register(, (runtimeMXBean) -> (String[])runtimeMXBean.getInputArguments().toArray((x$) -> [x$]), Codec.STRING_ARRAY);
usageThreshold.register(, RuntimeMXBean::getSystemProperties, (Codec.STRING, HashMap::));
METRICS_REGISTRY.register(, (aVoid) -> ManagementFactory.getRuntimeMXBean(), usageThreshold);
usageThreshold = <MemoryPoolMXBean>();
usageThreshold.register(, (memoryMXBean) -> memoryMXBean.getObjectPendingFinalizationCount(), Codec.INTEGER);
usageThreshold.register(, (memoryMXBean) -> memoryMXBean.getHeapMemoryUsage(), MEMORY_USAGE_METRICS_REGISTRY);
usageThreshold.register(, (memoryMXBean) -> memoryMXBean.getNonHeapMemoryUsage(), MEMORY_USAGE_METRICS_REGISTRY);
METRICS_REGISTRY.register(, (aVoid) -> ManagementFactory.getMemoryMXBean(), usageThreshold);
METRICS_REGISTRY.register(, (memoryMXBean) -> (GarbageCollectorMXBean[])ManagementFactory.getGarbageCollectorMXBeans().toArray((x$) -> [x$]), (GARBAGE_COLLECTOR_METRICS_REGISTRY, (x$) -> [x$]));
METRICS_REGISTRY.register(, (memoryMXBean) -> (MemoryPoolMXBean[])ManagementFactory.getMemoryPoolMXBeans().toArray((x$) -> [x$]), (MEMORY_POOL_METRICS_REGISTRY, (x$) -> [x$]));
METRICS_REGISTRY.register(, (aVoid) -> {
ManagementFactory.getThreadMXBean();
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(, );
Map<Thread, StackTraceElement[]> stackTraces = Thread.getAllStackTraces();
Long2ObjectOpenHashMap<Thread> threadIdMap = <Thread>();
(Thread thread : stackTraces.keySet()) {
threadIdMap.put(thread.getId(), thread);
}
ThreadMetricData[] data = [threadInfos.length];
( ; i < threadInfos.length; ++i) {
threadInfos[i];
data[i] = (threadInfo, threadIdMap.get(threadInfo.getThreadId()), threadMXBean);
}
data;
}, (JVMMetrics.ThreadMetricData.METRICS_REGISTRY, (x$) -> [x$]));
METRICS_REGISTRY.register(, (aVoid) -> {
System.getSecurityManager();
securityManager == ? : securityManager.getClass().getName();
}, Codec.STRING);
usageThreshold = <MemoryPoolMXBean>();
usageThreshold.register(, ClassLoadingMXBean::getLoadedClassCount, Codec.INTEGER);
usageThreshold.register(, ClassLoadingMXBean::getUnloadedClassCount, Codec.LONG);
usageThreshold.register(, ClassLoadingMXBean::getTotalLoadedClassCount, Codec.LONG);
usageThreshold.register(, (unused) -> ClassLoader.getSystemClassLoader(), CLASS_LOADER_METRICS_REGISTRY);
usageThreshold.register(, (unused) -> JVMMetrics.class.getClassLoader(), CLASS_LOADER_METRICS_REGISTRY);
METRICS_REGISTRY.register(, (aVoid) -> ManagementFactory.getClassLoadingMXBean(), usageThreshold);
}
{
MetricsRegistry<StackTraceElement> STACK_TRACE_ELEMENT_METRICS_REGISTRY = <StackTraceElement>();
MetricsRegistry<ThreadMetricData> METRICS_REGISTRY;
ThreadInfo threadInfo;
Thread thread;
ThreadMXBean threadMXBean;
{
.threadInfo = threadInfo;
.thread = thread;
.threadMXBean = threadMXBean;
}
{
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getFileName, Codec.STRING);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getLineNumber, Codec.INTEGER);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getModuleName, Codec.STRING);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getModuleVersion, Codec.STRING);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getClassLoaderName, Codec.STRING);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getClassName, Codec.STRING);
STACK_TRACE_ELEMENT_METRICS_REGISTRY.register(, StackTraceElement::getMethodName, Codec.STRING);
METRICS_REGISTRY = <ThreadMetricData>();
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getThreadId(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getThreadName(), Codec.STRING);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getThreadState(), (Thread.State.class));
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getPriority(), Codec.INTEGER);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.isDaemon(), Codec.BOOLEAN);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadMXBean.getThreadCpuTime(threadMetricData.threadInfo.getThreadId()), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getWaitedTime(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getWaitedCount(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getBlockedTime(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getBlockedCount(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getLockName(), Codec.STRING);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getLockOwnerId(), Codec.LONG);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getLockOwnerName(), Codec.STRING);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.threadInfo.getStackTrace(), (STACK_TRACE_ELEMENT_METRICS_REGISTRY, (x$) -> [x$]));
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.thread InitStackThread ? ((InitStackThread)threadMetricData.thread).getInitStack() : , (STACK_TRACE_ELEMENT_METRICS_REGISTRY, (x$) -> [x$]));
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.thread != ? threadMetricData.thread.isInterrupted() : , Codec.BOOLEAN);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.thread != ? threadMetricData.thread.getClass().getName() : , Codec.STRING);
MetricsRegistry<ThreadGroup> threadGroup = <ThreadGroup>();
threadGroup.register(, ThreadGroup::getName, Codec.STRING);
threadGroup.register(, ThreadGroup::getParent, threadGroup);
threadGroup.register(, ThreadGroup::getMaxPriority, Codec.INTEGER);
threadGroup.register(, ThreadGroup::isDestroyed, Codec.BOOLEAN);
threadGroup.register(, ThreadGroup::isDaemon, Codec.BOOLEAN);
threadGroup.register(, ThreadGroup::activeCount, Codec.INTEGER);
threadGroup.register(, ThreadGroup::activeGroupCount, Codec.INTEGER);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.thread != ? threadMetricData.thread.getThreadGroup() : , threadGroup);
METRICS_REGISTRY.register(, (threadMetricData) -> threadMetricData.thread != ? threadMetricData.thread.getUncaughtExceptionHandler().getClass().getName() : , Codec.STRING);
}
}
}
com/hypixel/hytale/metrics/MetricProvider.java
package com.hypixel.hytale.metrics;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public interface MetricProvider {
@Nullable
MetricResults toMetricResults();
@Nonnull
static <T, R> Function<T, MetricProvider> maybe(@Nonnull Function<T, R> func) {
return (t) -> {
R r = (R)func.apply(t);
return r instanceof MetricProvider ? (MetricProvider)r : null;
};
}
}
com/hypixel/hytale/metrics/MetricResults.java
package com.hypixel.hytale.metrics;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;
public class MetricResults {
public static final Codec<MetricResults> CODEC = new MetricResultsCodec();
public static final Codec<MetricResults[]> ARRAY_CODEC;
private final BsonDocument bson;
protected MetricResults(BsonDocument bson) {
this.bson = bson;
}
protected BsonDocument getBson() {
return this.bson;
}
static {
ARRAY_CODEC = new ArrayCodec<MetricResults[]>(CODEC, (x$0) -> new MetricResults[x$]);
}
<MetricResults> {
{
}
MetricResults {
Codec.isNullBsonValue(bsonValue) ? : (bsonValue.asDocument());
}
BsonValue {
metricResults == ? : metricResults.bson;
}
MetricResults IOException {
RawJsonReader.readBsonValue(reader);
Codec.isNullBsonValue(bsonValue) ? : (bsonValue.asDocument());
}
Schema {
();
}
}
}
com/hypixel/hytale/metrics/MetricsRegistry.java
package com.hypixel.hytale.metrics;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.backend.HytaleFileHandler;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.locks.StampedLock;
import java.util.function.Function;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;
import org.bson.codecs.BsonDocumentCodec;
import org.bson.codecs.EncoderContext;
import org.bson.json.JsonMode;
import org.bson.json.JsonWriter;
import org.bson.json.JsonWriterSettings;
public class MetricsRegistry<T> implements Codec<T> {
private static final HytaleLogger LOGGER HytaleLogger.forEnclosingClass();
JsonWriterSettings JSON_SETTINGS;
EncoderContext ENCODER_CONTEXT;
BsonDocumentCodec BSON_DOCUMENT_CODEC;
Function<T, MetricProvider> appendFunc;
();
Map<String, Metric<T, ?>> map = <String, Metric<T, ?>>();
{
.appendFunc = ;
}
{
.appendFunc = appendFunc;
}
MetricsRegistry<T> {
.lock.writeLock();
{
(.map.putIfAbsent(id, ((Function), metricsRegistry)) != ) {
( + id);
}
} {
.lock.unlockWrite(stamp);
}
;
}
<R> MetricsRegistry<T> {
.lock.writeLock();
{
(.map.putIfAbsent(id, (func, codec)) != ) {
( + id);
}
} {
.lock.unlockWrite(stamp);
}
;
}
<R > MetricsRegistry<T> {
.register(id, func.andThen((r) -> r == ? : r.toMetricResults()), MetricResults.CODEC);
}
<R> MetricsRegistry<T> {
.lock.writeLock();
{
(.map.putIfAbsent(id, (func, codecFunc)) != ) {
( + id);
}
} {
.lock.unlockWrite(stamp);
}
;
}
T {
();
}
BsonValue {
();
.lock.readLock();
{
(Map.Entry<String, Metric<T, ?>> entry : .map.entrySet()) {
(String)entry.getKey();
((Metric)entry.getValue()).encode(t, extraInfo);
(value != ) {
document.put(key, value);
}
}
} {
.lock.unlockRead(stamp);
}
(.appendFunc != ) {
(MetricProvider).appendFunc.apply(t);
(metricProvider != ) {
metricProvider.toMetricResults();
(metricResults != ) {
document.putAll(metricResults.getBson());
}
}
}
document;
}
Schema {
();
}
MetricResults {
(.dumpToBson(t).asDocument());
}
BsonValue {
(ExtraInfo)ExtraInfo.THREAD_LOCAL.get();
.encode(t, extraInfo).asDocument();
extraInfo.getValidationResults().logOrThrowValidatorExceptions(LOGGER);
bson;
}
Path IOException {
createDumpPath();
.dumpToJson(path, t);
path;
}
IOException {
.dumpToBson(t);
Files.newBufferedWriter(path);
{
BSON_DOCUMENT_CODEC.encode( (writer, JSON_SETTINGS), (BsonDocument)bson.asDocument(), ENCODER_CONTEXT);
} (Throwable var8) {
(writer != ) {
{
writer.close();
} (Throwable var7) {
var8.addSuppressed(var7);
}
}
var8;
}
(writer != ) {
writer.close();
}
}
Path IOException {
createDumpPath((String), ext);
}
Path {
createDatePath(dir, (String), ext);
}
Path IOException {
Paths.get();
(!Files.exists(path, [])) {
Files.createDirectories(path);
}
createDatePath(path, prefix, ext);
}
Path {
HytaleFileHandler.LOG_FILE_DATE_FORMAT.format(LocalDateTime.now());
(prefix != ) {
name = prefix + name;
}
suffix != ? dir.resolve(name + suffix) : dir.resolve(name);
;
(Files.exists(file, [])) {
(suffix != ) {
file = dir.resolve(name + + i++ + suffix);
} {
file = dir.resolve(name + + i++);
}
}
file;
}
{
JSON_SETTINGS = JsonWriterSettings.builder().outputMode(JsonMode.STRICT).indent().newLineCharacters().int64Converter((value, writer) -> writer.writeNumber(Long.toString(value))).build();
ENCODER_CONTEXT = EncoderContext.builder().build();
BSON_DOCUMENT_CODEC = ();
}
<T, R> {
Function<T, R> func;
Codec<R> codec;
Function<R, MetricsRegistry<R>> codecFunc;
{
.func = func;
.codec = codec;
.codecFunc = ;
}
{
.func = func;
.codec = ;
.codecFunc = codecFunc;
}
BsonValue {
(.func == ) {
.codec != ;
.codec.encode((Object), extraInfo);
} {
(R).func.apply(t);
value == ? : .getCodec(value).encode(value, extraInfo);
}
}
Codec<R> {
(.codec != ) {
.codec;
} {
.codecFunc != ;
(Codec).codecFunc.apply(value);
}
}
}
}
com/hypixel/hytale/metrics/metric/AverageCollector.java
package com.hypixel.hytale.metrics.metric;
public class AverageCollector {
private double val = 0.0;
private long n = 0L;
public AverageCollector() {
}
public double get() {
return this.val;
}
public long size() {
return this.n;
}
public double addAndGet(double v) {
this.add(v);
return this.get();
}
public void add(double v) {
++this.n;
this.val = this.val - this.val / (double)this.n + v / (double)this.n;
}
public void {
(.n == ) {
.n = ;
.val = ;
} (.n > ) {
.val = (.val - v / ().n) / ( - / ().n);
--.n;
}
}
{
.val = ;
.n = ;
}
{
val - val / ()n + v / ()n;
}
{
.n = ;
.val = v;
}
}
com/hypixel/hytale/metrics/metric/HistoricMetric.java
package com.hypixel.hytale.metrics.metric;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.util.MathUtil;
import it.unimi.dsi.fastutil.longs.LongArrayList;
import it.unimi.dsi.fastutil.longs.LongList;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nonnull;
public class HistoricMetric {
public static final HistoricMetric[] EMPTY_ARRAY = new HistoricMetric[0];
public static final Codec<HistoricMetric> METRICS_CODEC;
private final long[] periodsNanos;
@Nonnull
private final AverageCollector[] periodAverages;
@Nonnull
private final int[] startIndices;
private final int bufferSize;
@Nonnull
private final long[] timestamps;
@Nonnull
private final long[] values;
int nextIndex;
private {
();
}
{
.periodsNanos = builder.periods.toLongArray();
.periodAverages = [.periodsNanos.length];
( ; i < .periodAverages.length; ++i) {
.periodAverages[i] = ();
}
.startIndices = [.periodsNanos.length];
;
( period : .periodsNanos) {
(period > longestPeriod) {
longestPeriod = period;
}
}
.bufferSize = ()MathUtil.fastCeil(()longestPeriod / ()builder.minimumInterval);
.timestamps = [.bufferSize];
.values = [.bufferSize];
Arrays.fill(.timestamps, );
}
[] getPeriodsNanos() {
.periodsNanos;
}
{
.bufferSize;
[] values = .values;
.startIndices[periodIndex];
.nextIndex;
;
(start < nextIndex) {
( start; i < nextIndex; ++i) {
values[i];
(value < min) {
min = value;
}
}
} {
( start; i < bufferSize; ++i) {
values[i];
(value < min) {
min = value;
}
}
( ; i < nextIndex; ++i) {
values[i];
(value < min) {
min = value;
}
}
}
min;
}
{
.periodAverages[periodIndex].get();
}
{
.bufferSize;
[] values = .values;
.startIndices[periodIndex];
.nextIndex;
-;
(start < nextIndex) {
( start; i < nextIndex; ++i) {
values[i];
(value > max) {
max = value;
}
}
} {
( start; i < bufferSize; ++i) {
values[i];
(value > max) {
max = value;
}
}
( ; i < nextIndex; ++i) {
values[i];
(value > max) {
max = value;
}
}
}
max;
}
{
(AverageCollector average : .periodAverages) {
average.clear();
}
Arrays.fill(.startIndices, );
Arrays.fill(.timestamps, );
Arrays.fill(.values, );
.nextIndex = ;
}
{
[] periodsNanos = .periodsNanos;
AverageCollector[] periodAverages = .periodAverages;
[] startIndices = .startIndices;
.bufferSize;
[] timestamps = .timestamps;
[] values = .values;
.nextIndex;
periodsNanos.length;
( ; i < periodLength; ++i) {
timestampNanos - periodsNanos[i];
periodAverages[i];
startIndices[i];
(timestamps[start] < oldestPossibleTimestamp) {
values[start];
average.remove(()oldValue);
start = (start + ) % bufferSize;
(start == nextIndex) {
;
}
}
startIndices[i] = start;
average.add(()value);
}
timestamps[nextIndex] = timestampNanos;
values[nextIndex] = value;
.nextIndex = (nextIndex + ) % bufferSize;
}
[] getTimestamps( periodIndex) {
.startIndices[periodIndex];
[] timestamps = .timestamps;
.nextIndex;
(start < nextIndex) {
Arrays.copyOfRange(timestamps, start, nextIndex);
} {
timestamps.length - start;
[] data = [length + nextIndex];
System.arraycopy(timestamps, start, data, , length);
System.arraycopy(timestamps, , data, length, nextIndex);
data;
}
}
[] getValues( periodIndex) {
.startIndices[periodIndex];
[] values = .values;
.nextIndex;
(start < nextIndex) {
Arrays.copyOfRange(values, start, nextIndex);
} {
.bufferSize - start;
[] data = [length + nextIndex];
System.arraycopy(values, start, data, , length);
System.arraycopy(values, , data, length, nextIndex);
data;
}
}
[] getAllTimestamps() {
.getTimestamps(.periodsNanos.length - );
}
[] getAllValues() {
.getValues(.periodsNanos.length - );
}
{
timestamps.length;
System.arraycopy(timestamps, , .timestamps, , length);
;
timestamps[length - ];
( length - ; i >= ; --i) {
(last - timestamps[i] >= .periodsNanos[periodIndex]) {
.startIndices[periodIndex] = i + ;
++periodIndex;
(periodIndex >= .periodsNanos.length) {
;
}
}
}
(periodIndex < .periodsNanos.length) {
(periodIndex < .periodsNanos.length) {
.periodsNanos[periodIndex] = ;
++periodIndex;
}
}
.nextIndex = length;
}
{
System.arraycopy(values, , .values, , values.length);
}
{
.nextIndex == ? .values[.bufferSize - ] : .values[.nextIndex - ];
}
Builder {
(minimumInterval, unit);
}
{
METRICS_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(HistoricMetric.class, HistoricMetric::).append( (, Codec.LONG_ARRAY), (historicMetric, s) -> {
();
}, (historicMetric) -> historicMetric.periodsNanos).add()).append( (, Codec.LONG_ARRAY), (historicMetric, s) -> {
();
}, HistoricMetric::getAllTimestamps).add()).append( (, Codec.LONG_ARRAY), (historicMetric, s) -> {
();
}, HistoricMetric::getAllValues).add()).build();
}
{
minimumInterval;
();
{
.minimumInterval = unit.toNanos(minimumInterval);
}
Builder {
unit.toNanos(period);
( ; i < .periods.size(); ++i) {
(.periods.getLong(i) > nanos) {
();
}
}
.periods.add(nanos);
;
}
HistoricMetric {
();
}
}
}
com/hypixel/hytale/metrics/metric/Metric.java
package com.hypixel.hytale.metrics.metric;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;
public class Metric {
public static final Codec<Metric> CODEC;
private long min;
private final AverageCollector average = new AverageCollector();
private long max;
public Metric() {
this.clear();
}
public void add(long value) {
if (value < this.min) {
this.min = value;
}
this.average.add((double)value);
if (value > this.max) {
this.max = value;
}
}
public void remove(long value) {
this.average.remove((double)value);
}
public {
.min;
}
{
.average.get();
}
{
.max;
}
{
.min = ;
.average.clear();
.max = -;
}
{
.min = ;
.max = -;
}
{
(value < .min) {
.min = value;
}
(value > .max) {
.max = value;
}
}
{
.average.add(()value);
}
{
.min = metric.min;
.average.set(metric.average.get());
.max = metric.max;
}
String {
.min;
+ var10000 + + .average.get() + + .max + ;
}
{
CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Metric.class, Metric::).append( (, Codec.LONG), (metric, s) -> metric.min = s, (metric) -> metric.min).add()).append( (, Codec.DOUBLE), (metric, s) -> metric.average.set(s), (metric) -> metric.average.get()).add()).append( (, Codec.LONG), (metric, s) -> metric.max = s, (metric) -> metric.max).add()).build();
}
}
com/hypixel/hytale/metrics/metric/SynchronizedAverageCollector.java
package com.hypixel.hytale.metrics.metric;
public class SynchronizedAverageCollector extends AverageCollector {
public SynchronizedAverageCollector() {
}
public synchronized double get() {
return super.get();
}
public synchronized long size() {
return super.size();
}
public synchronized double addAndGet(double v) {
return super.addAndGet(v);
}
public synchronized void add(double v) {
super.add(v);
}
public synchronized void remove(double v) {
super.remove(v);
}
public synchronized void clear() {
.clear();
}
}