com/hypixel/hytale/metrics

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();
   }
}