How to use

MonitorUtils

in

org.apache.druid.java.util.metrics

 private ServiceMetricEvent.Builder createEventBuilder(String serviceName)
 {
  ServiceMetricEvent.Builder builder = ServiceMetricEvent.builder()
                              .setDimension("serviceName", serviceName);
  MonitorUtils.addDimensionsToBuilder(builder, dimensions);
  return builder;
 }
}

 @Override
 public boolean doMonitor(ServiceEmitter emitter)
 {
  final ServiceMetricEvent.Builder builder = new ServiceMetricEvent.Builder();
  MonitorUtils.addDimensionsToBuilder(builder, dimensions);
  emitter.emit(builder.build("jetty/numOpenConnections", activeConnections.get()));
  return true;
 }
}

private void emitThreadAllocationMetrics(ServiceEmitter emitter)
{
 final ServiceMetricEvent.Builder builder = builder();
 MonitorUtils.addDimensionsToBuilder(builder, dimensions);
 if (collector != null) {
  long delta = collector.calculateDelta();
  emitter.emit(builder.build("jvm/heapAlloc/bytes", delta));
 }
}

MonitorUtils.addDimensionsToBuilder(builder, dimensions);

  .setDimension("cpuName", name)
  .setDimension("cpuTime", entry.getKey());
MonitorUtils.addDimensionsToBuilder(builder, dimensions);
emitter.emit(builder.build("sys/cpu", entry.getValue() * 100 / total)); // [0,100]

 @Override
 public boolean doMonitor(ServiceEmitter emitter)
 {
  final Memory memory = new Memory(cgroupDiscoverer);
  final Memory.MemoryStat stat = memory.snapshot();
  stat.getMemoryStats().forEach((key, value) -> {
   final ServiceMetricEvent.Builder builder = builder();
   MonitorUtils.addDimensionsToBuilder(builder, dimensions);
   // See https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt
   // There are inconsistent units for these. Most are bytes.
   emitter.emit(builder.build(StringUtils.format("cgroup/memory/%s", key), value));
  });
  stat.getNumaMemoryStats().forEach((key, value) -> {
   final ServiceMetricEvent.Builder builder = builder().setDimension("numaZone", Long.toString(key));
   MonitorUtils.addDimensionsToBuilder(builder, dimensions);
   value.forEach((k, v) -> emitter.emit(builder.build(StringUtils.format("cgroup/memory_numa/%s/pages", k), v)));
  });
  return true;
 }
}

 @Override
 public void emit(ServiceEmitter emitter)
 {
  for (String dir : dirList) {
   DirUsage du = null;
   try {
    du = sigar.getDirUsage(dir);
   }
   catch (SigarException e) {
    log.error("Failed to get DiskUsage for [%s] due to   [%s]", dir, e.getMessage());
   }
   if (du != null) {
    final Map<String, Long> stats = ImmutableMap.of(
      "sys/storage/used", du.getDiskUsage()
    );
    final ServiceMetricEvent.Builder builder = builder()
      .setDimension("fsDirName", dir); // fsDirName because FsStats uses fsDirName
    MonitorUtils.addDimensionsToBuilder(builder, dimensions);
    for (Map.Entry<String, Long> entry : stats.entrySet()) {
     emitter.emit(builder.build(entry.getKey(), entry.getValue()));
    }
   }
  }
 }
}

 @Override
 public void emit(ServiceEmitter emitter)
 {
  Mem mem = null;
  try {
   mem = sigar.getMem();
  }
  catch (SigarException e) {
   log.error(e, "Failed to get Mem");
  }
  if (mem != null) {
   final Map<String, Long> stats = ImmutableMap.of(
     "sys/mem/max", mem.getTotal(),
     "sys/mem/used", mem.getUsed(),
     "sys/mem/actual/used", mem.getActualUsed(),
     "sys/mem/actual/free", mem.getActualFree()
   );
   final ServiceMetricEvent.Builder builder = builder();
   MonitorUtils.addDimensionsToBuilder(builder, dimensions);
   for (Map.Entry<String, Long> entry : stats.entrySet()) {
    emitter.emit(builder.build(entry.getKey(), entry.getValue()));
   }
  }
 }
}

final MemoryUsage usage = entry.getValue();
final ServiceMetricEvent.Builder builder = builder().setDimension("memKind", kind);
MonitorUtils.addDimensionsToBuilder(builder, dimensions);
  .setDimension("poolKind", kind)
  .setDimension("poolName", pool.getName());
MonitorUtils.addDimensionsToBuilder(builder, dimensions);

 @Override
 public void emit(ServiceEmitter emitter)
 {
  Swap swap = null;
  try {
   swap = sigar.getSwap();
  }
  catch (SigarException e) {
   log.error(e, "Failed to get Swap");
  }
  if (swap != null) {
   long currPageIn = swap.getPageIn();
   long currPageOut = swap.getPageOut();
   final Map<String, Long> stats = ImmutableMap.of(
     "sys/swap/pageIn", (currPageIn - prevPageIn),
     "sys/swap/pageOut", (currPageOut - prevPageOut),
     "sys/swap/max", swap.getTotal(),
     "sys/swap/free", swap.getFree()
   );
   final ServiceMetricEvent.Builder builder = builder();
   MonitorUtils.addDimensionsToBuilder(builder, dimensions);
   for (Map.Entry<String, Long> entry : stats.entrySet()) {
    emitter.emit(builder.build(entry.getKey(), entry.getValue()));
   }
   this.prevPageIn = currPageIn;
   this.prevPageOut = currPageOut;
  }
 }
}

MonitorUtils.addDimensionsToBuilder(builder, dimensions);

void emit(ServiceEmitter emitter, Map<String, String[]> dimensions)
{
 final ServiceMetricEvent.Builder builder = builder();
 MonitorUtils.addDimensionsToBuilder(builder, dimensions);
 long newInvocations = invocationsCounter.getLong();
 emitter.emit(builder.build("jvm/gc/count", newInvocations - lastInvocations));
 lastInvocations = newInvocations;
 long newCpuNanos = cpuCounter.getNanos();
 emitter.emit(builder.build("jvm/gc/cpu", newCpuNanos - lastCpuNanos));
 lastCpuNanos = newCpuNanos;
}

 @Override
 public boolean doMonitor(ServiceEmitter emitter)
 {
  // process CPU
  try {
   ProcCpu procCpu = sigar.getProcCpu(currentProcessId);
   final ServiceMetricEvent.Builder builder = builder();
   MonitorUtils.addDimensionsToBuilder(builder, dimensions);
   // delta for total, sys, user
   Map<String, Long> procDiff = diff.to(
     "proc/cpu", ImmutableMap.of(
       "jvm/cpu/total", procCpu.getTotal(),
       "jvm/cpu/sys", procCpu.getSys(),
       "jvm/cpu/user", procCpu.getUser()
     )
   );
   if (procDiff != null) {
    for (Map.Entry<String, Long> entry : procDiff.entrySet()) {
     emitter.emit(builder.build(entry.getKey(), entry.getValue()));
    }
   }
   emitter.emit(builder.build("jvm/cpu/percent", procCpu.getPercent()));
  }
  catch (SigarException e) {
   log.error(e, "Failed to get ProcCpu");
  }
  return true;
 }
}

  .setDimension("fsSysTypeName", fs.getSysTypeName())
  .setDimension("fsOptions", fs.getOptions().split(","));
MonitorUtils.addDimensionsToBuilder(builder, dimensions);
for (Map.Entry<String, Long> entry : stats.entrySet()) {
 emitter.emit(builder.build(entry.getKey(), entry.getValue()));

 @Test
 public void testAddDimensionsToBuilder()
 {
  ServiceMetricEvent.Builder builder = new ServiceMetricEvent.Builder();
  Map<String, String[]> dimensions = ImmutableMap.of(
    "dim1", new String[]{"value1"},
    "dim2", new String[]{"value2.1", "value2.2"}
  );

  MonitorUtils.addDimensionsToBuilder(builder, dimensions);

  Assert.assertEquals(builder.getDimension("dim1"), ImmutableList.of("value1"));
  Assert.assertEquals(builder.getDimension("dim2"), ImmutableList.of("value2.1", "value2.2"));
 }
}

  .setDimension("netAddress", netconf.getAddress())
  .setDimension("netHwaddr", netconf.getHwaddr());
MonitorUtils.addDimensionsToBuilder(builder, dimensions);
for (Map.Entry<String, Long> entry : stats.entrySet()) {
 emitter.emit(builder.build(entry.getKey(), entry.getValue()));

  .setDimension("fsSysTypeName", fs.getSysTypeName())
  .setDimension("fsOptions", fs.getOptions().split(","));
MonitorUtils.addDimensionsToBuilder(builder, dimensions);
for (Map.Entry<String, Long> entry : stats.entrySet()) {
 emitter.emit(builder.build(entry.getKey(), entry.getValue()));

 @Override
 public boolean doMonitor(ServiceEmitter emitter)
 {
  ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();

  final ServiceMetricEvent.Builder builder = builder();
  MonitorUtils.addDimensionsToBuilder(builder, dimensions);

  // Because between next two calls on ThreadMXBean new threads can be started we can observe some inconsistency
  // in counters values and finished counter could be even negative
  int newLiveThreads = threadBean.getThreadCount();
  long newStartedThreads = threadBean.getTotalStartedThreadCount();

  long startedThreadsDiff = newStartedThreads - lastStartedThreads;

  emitter.emit(builder.build("jvm/threads/started", startedThreadsDiff));
  emitter.emit(builder.build("jvm/threads/finished", lastLiveThreads + startedThreadsDiff - newLiveThreads));
  emitter.emit(builder.build("jvm/threads/live", newLiveThreads));
  emitter.emit(builder.build("jvm/threads/liveDaemon", threadBean.getDaemonThreadCount()));

  emitter.emit(builder.build("jvm/threads/livePeak", threadBean.getPeakThreadCount()));
  threadBean.resetPeakThreadCount();

  lastStartedThreads = newStartedThreads;
  lastLiveThreads = newLiveThreads;

  return true;
 }
}

  .setDimension("cpuName", Integer.toString(i))
  .setDimension("cpuTime", "sys");
MonitorUtils.addDimensionsToBuilder(builderUsr, dimensions);
MonitorUtils.addDimensionsToBuilder(builderSys, dimensions);
emitter.emit(builderUsr.build(
  dateTime,

private void emitDirectMemMetrics(ServiceEmitter emitter)
{
 for (BufferPoolMXBean pool : ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class)) {
  final ServiceMetricEvent.Builder builder = builder().setDimension("bufferpoolName", pool.getName());
  MonitorUtils.addDimensionsToBuilder(builder, dimensions);
  emitter.emit(builder.build("jvm/bufferpool/capacity", pool.getTotalCapacity()));
  emitter.emit(builder.build("jvm/bufferpool/used", pool.getMemoryUsed()));
  emitter.emit(builder.build("jvm/bufferpool/count", pool.getCount()));
 }
}