//设置package包名称以及导入依赖的类
package com.onur.moviedb.metric

import java.lang.management.ManagementFactory
import java.util.concurrent.TimeUnit

import com.codahale.metrics.health.HealthCheckRegistry
import com.codahale.metrics.{JmxReporter, MetricRegistry, Slf4jReporter}
import com.codahale.metrics.jvm.{BufferPoolMetricSet, GarbageCollectorMetricSet, MemoryUsageGaugeSet, ThreadStatesGaugeSet}
import org.slf4j.LoggerFactory


object Metrics {
  lazy val metricRegistry: MetricRegistry = {
    val metricRegistry: MetricRegistry = new MetricRegistry
    Slf4jReporter.forRegistry(metricRegistry)
      .outputTo(LoggerFactory.getLogger("metrics"))
      .convertRatesTo(TimeUnit.SECONDS)
      .convertDurationsTo(TimeUnit.MILLISECONDS)
      .build
      .start(30, TimeUnit.SECONDS)
    JmxReporter.forRegistry(metricRegistry).build.start()
    metricRegistry.register("jvm-gc", new GarbageCollectorMetricSet)
    metricRegistry.register("jvm-buffer", new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer))
    metricRegistry.register("jvm-memory", new MemoryUsageGaugeSet)
    metricRegistry.register("jvm-threads", new ThreadStatesGaugeSet)
    metricRegistry
  }

  lazy val healthCheckRegistry = new HealthCheckRegistry
} 

//设置package包名称以及导入依赖的类
package service.health

import java.lang.management.ManagementFactory

import akka.http.scaladsl.server.Directives._

import scala.concurrent.duration._

trait HealthRoutes {

  def healthRoutes = pathPrefix("health") {
    path("ping") {
      get {
          complete("OK")
        }
      } ~ path("uptime") {
      get {
        complete(getUptime.toString)
      }
    }
  }
  
  private def getUptime = Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toSeconds
} 

//设置package包名称以及导入依赖的类
// Copyright (c) Microsoft.All rights reserved.

package com.microsoft.azure.iot.iothub2cassandra.webservice

import java.lang.management.ManagementFactory

import spray.json.{JsNumber, JsObject, JsString, JsValue}

object Status {
  def get: JsValue = {
    val runtimeMXB = ManagementFactory.getRuntimeMXBean
    val osMXB = ManagementFactory.getOperatingSystemMXBean

    val runtime = JsObject(
      "startTime" ? JsNumber(runtimeMXB.getStartTime),
      "uptimeMsecs" ? JsNumber(runtimeMXB.getUptime),
      "name" ? JsString(runtimeMXB.getName),
      "vmName" ? JsString(runtimeMXB.getVmName)
    )

    val os = JsObject(
      "arch" ? JsString(osMXB.getArch),
      "name" ? JsString(osMXB.getName),
      "version" ? JsString(osMXB.getVersion),
      "processors" ? JsNumber(osMXB.getAvailableProcessors),
      "systemLoadAvg" ? JsNumber(osMXB.getSystemLoadAverage)
    )

    JsObject(
      "runtime" ? runtime,
      "os" ? os
    )
  }
} 

//设置package包名称以及导入依赖的类
package ppl.delite.runtime
package profiler

import ppl.delite.runtime.Config
import ppl.delite.runtime.graph.DeliteTaskGraph
import java.lang.management.ManagementFactory


//front-facing interface to activate all profiling tools
object Profiling {

  private var globalStartNanos = 0L
  private var jvmUpTime = 0L

  def init(graph: DeliteTaskGraph) {
    Profiler.init(graph)
    val totalResources = Config.numThreads + Config.numCpp + Config.numCuda + Config.numOpenCL
    PerformanceTimer.initializeStats(totalResources)
    MemoryProfiler.initializeStats(totalResources)
  }

  def startRun() {
    PerformanceTimer.clearAll()
    globalStartNanos = System.nanoTime()
    jvmUpTime = ManagementFactory.getRuntimeMXBean().getUptime()
    PerformanceTimer.start("all", false)
  }

  def endRun() {
    PerformanceTimer.stop("all", false)
    PerformanceTimer.printStatsForNonKernelComps()
    if (Config.dumpProfile) Profiler.dumpProfile(globalStartNanos, jvmUpTime)  
    if (Config.dumpStats) PerformanceTimer.dumpStats()   
  }

} 

//设置package包名称以及导入依赖的类
package br.com.verde.serverstats

import com.twitter.finatra.http.Controller
import com.google.inject.Inject
import com.twitter.finatra.validation._
import com.google.inject.Singleton
import com.twitter.finagle.http.Request
import java.lang.management.ManagementFactory
import java.lang.management.OperatingSystemMXBean
import java.io.File

@Singleton
class ServerStatsController @Inject() extends Controller {

  val runtime = Runtime.getRuntime

  val osBean = ManagementFactory.getOperatingSystemMXBean
  val runtimeBean = ManagementFactory.getRuntimeMXBean
  val memoryBean = ManagementFactory.getMemoryMXBean

  val megabyte = 1024 * 1024
  val second = 1000 // milisecond

  get("/serverStats") {
    request: Request =>

      val jvmTotalRam = runtime.maxMemory
      val jvmFreeRam = runtime.freeMemory
      val availableProcessors = osBean.getAvailableProcessors

      val freeSpace = File.listRoots.head.getFreeSpace

      val serverSystemLoad = osBean.getSystemLoadAverage
      val serverUptime = runtimeBean.getUptime

      val param = request.getParam("onlyRam")
      if (param == null) {
        response
          .ok
          .json(s"""{ "jvm_total_ram": "${jvmTotalRam / megabyte} Mb",
          "jvm_free_ram": "${jvmFreeRam / megabyte} Mb",
          "free_space": "${freeSpace / megabyte} Mb",
          "server_system_load": "${serverSystemLoad} %",
          "server_uptime": "${serverUptime / second} s",
          "available_processors": "${availableProcessors}" }""")
      } else {
        response
          .ok
          .json(s"""{ "jvm_total_ram": "${jvmTotalRam / megabyte} Mb",
          "jvm_free_ram": "${jvmFreeRam / megabyte} Mb" }""")
      }
  }
} 

//设置package包名称以及导入依赖的类
package org.romanowski.hoarder.core

import java.io.File
import java.lang.management.ManagementFactory
import java.nio.file.Path
import java.nio.file.Paths

import sbt.Attributed
import sbt.Keys.artifact
import sbt.Keys.moduleID

class SbtClasspathMapper(projectRoot: Path,
                         classpath: Seq[Attributed[File]],
                         includeSize: Boolean = false) {

  def read(descriptor: String): Option[File] = classpathDescriptors.get(descriptor)

  def write(f: File): Option[String] =
    classpath.find(_.data == f).flatMap(stringifyAttributes)
    .orElse(asJVMJar(f.toPath))

  private def stringifyAttributes(from: Attributed[File]): Option[String] = for {
    artifact <- from.get(artifact.key)
    module <- from.get(moduleID.key)
  } yield {
    Seq(module.organization,
      module.revision,
      module.name,
      from.data.getName,
      artifact.classifier.getOrElse("-"),
      module.configurations.getOrElse("-"),
      if (includeSize) from.data.length() else -1
    ).mkString("#")
  }

  private def asJVMJar(filePath: Path): Option[String] = for {
    javaHome <- Option(System.getProperty("java.home"))
    javaHomePath = Paths.get(javaHome)
    if filePath.startsWith(javaHomePath)
    javaVersion <- Option(System.getProperty("java.specification.version"))
    relativePath = javaHomePath.relativize(filePath)
  } yield s"##$javaVersion##$relativePath"


  private lazy val jvmClasspath: Map[String, File] = if (ManagementFactory.getRuntimeMXBean.isBootClassPathSupported)
    ManagementFactory.getRuntimeMXBean.getBootClassPath.split(File.pathSeparator).flatMap { s =>
      val path = Paths.get(s)
      val jvmJar = asJVMJar(path)
      jvmJar.map(_ -> path.toFile)
    }(collection.breakOut)
  else Map.empty

  private lazy val classpathDescriptors: Map[String, File] =
    jvmClasspath ++ classpath.map(stringifyAttributes).zip(classpath).collect {
      case (Some(k), attributted) => k -> attributted.data
    }(collection.breakOut)
} 

//设置package包名称以及导入依赖的类
package com.olegych.scastie.util

import java.nio.file._
import java.lang.management.ManagementFactory
import java.nio.charset.StandardCharsets
import System.{lineSeparator => nl}

object ScastieFileUtil {
  def slurp(src: Path): Option[String] = {
    if (Files.exists(src)) Some(Files.readAllLines(src).toArray.mkString(nl))
    else None
  }

  def write(dst: Path,
            content: String,
            truncate: Boolean = false,
            append: Boolean = false): Unit = {
    if (!Files.exists(dst)) {
      Files.write(dst, content.getBytes, StandardOpenOption.CREATE_NEW)
      ()
    } else if (truncate) {
      Files.write(dst, content.getBytes, StandardOpenOption.TRUNCATE_EXISTING)
      ()
    } else if (append) {
      Files.write(dst, content.getBytes, StandardOpenOption.APPEND)
      ()
    }
  }

  def writeRunningPid(): String = {
    val pid = ManagementFactory.getRuntimeMXBean.getName.split("@").head
    val pidFile = Paths.get("RUNNING_PID")
    Files.write(pidFile, pid.getBytes(StandardCharsets.UTF_8))
    sys.addShutdownHook {
      Files.delete(pidFile)
    }
    pid
  }
} 

//设置package包名称以及导入依赖的类
package de.choffmeister.kamon.influxdb

import java.lang.management.ManagementFactory

import akka.actor.ActorSystem
import com.typesafe.config.ConfigFactory
import kamon.Kamon

class InfluxDBExtensionTest extends UnitTest {
  Kamon.start()
  val hostname = ManagementFactory.getRuntimeMXBean.getName.split('@')(1)

  "InfluxDBExtension" should "add host tag if not given explicitly" in {
    val system = ActorSystem("InfluxDBExtensionTest1")
    val influxDB = InfluxDB(system)

    influxDB.tags("host") should be(hostname)

    system.terminate()
  }

  it should "read tags from config" in {
    val config = ConfigFactory.parseString(
      """kamon.influxdb {
        |  tags = [
        |    { host: "foobar" }
        |    { apple: "pie" }
        |  ]
        |}
      """.stripMargin)
    val system = ActorSystem("InfluxDBExtensionTest2", config)
    val influxDB = InfluxDB(system)

    influxDB.tags("host") should be("foobar")
    influxDB.tags("apple") should be("pie")

    system.terminate()
  }
} 

//设置package包名称以及导入依赖的类
package com.example.usecase.health

import java.lang.management.ManagementFactory

import akka.actor.{ActorRef, ActorSystem}
import akka.cluster.Cluster
import akka.http.scaladsl.server.Directives
import scala.concurrent.duration._
import scala.collection.JavaConversions._

import scala.concurrent.duration._

class HealthRoutes(clusterListener: ActorRef)(implicit val actorSystem: ActorSystem) extends Directives {

  val cluster = Cluster(actorSystem)

  val healthRoutes = pathPrefix("health") {
    path("ping") {
      get {
        complete("OK")
      }
    } ~ path("uptime") {
      get {
        complete(getUptime.toString + " seconds")
      }
    } ~ path("nodes") {
      complete(cluster.state.getMembers.toList.map(member => member.address).mkString(","))
    }
  }
  private def getUptime = Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toSeconds
} 

//设置package包名称以及导入依赖的类
package eu.inn.metrics

import java.lang.management.ManagementFactory
import com.sun.management.{OperatingSystemMXBean, UnixOperatingSystemMXBean}
import scala.collection.JavaConversions._

object ProcessMetrics {
  def startReporting(reporter: MetricsTracker): Unit = {
    ManagementFactory.getOperatingSystemMXBean match {
      case unix: UnixOperatingSystemMXBean ?
        reporter.gauge("system.fd.max")(unix.getMaxFileDescriptorCount)
        reporter.gauge("system.fd.open")(unix.getOpenFileDescriptorCount)

        reporter.gauge("system.cpu.time")(unix.getProcessCpuTime)
        reporter.gauge("system.cpu.load")((unix.getProcessCpuLoad * 100).toLong)

      case other: OperatingSystemMXBean ?
        reporter.gauge("system.cpu.time")(other.getProcessCpuTime)
        reporter.gauge("system.cpu.load")((other.getProcessCpuLoad * 100).toLong)
    }


    val mem = ManagementFactory.getMemoryMXBean
    reporter.gauge("system.heap.max")(mem.getHeapMemoryUsage.getMax)
    reporter.gauge("system.heap.used")(mem.getHeapMemoryUsage.getUsed)
    reporter.gauge("system.heap.committed")(mem.getHeapMemoryUsage.getCommitted)

    ManagementFactory.getGarbageCollectorMXBeans.foreach { gc ?
      reporter.gauge(s"gc.${gc.getName.replaceAll("[^\\w]+", "-")}.count")(gc.getCollectionCount)
      reporter.gauge(s"gc.${gc.getName.replaceAll("[^\\w]+", "-")}.time")(gc.getCollectionTime)
    }
  }
} 

//设置package包名称以及导入依赖的类
package g8.akkahttp.eventsvc

import java.lang.management.ManagementFactory

import akka.actor.ActorSystem
import akka.event.Logging
import akka.http.scaladsl.server.{Directives, StandardRoute}
import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport._

import scala.concurrent.duration._

class StatusService(system: ActorSystem) extends StatusServiceTrait {

  override protected def log      = Logging(system, "service")
  override protected def executor = system.dispatcher
}

trait StatusServiceTrait extends BaseComponent {
  import Directives._
  import g8.akkahttp.eventsvc.data._
  import io.circe.generic.auto._

  def getStatus: StandardRoute = {
    log.info("/status executed")
    complete(Status(Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toString()))
  }
} 

//设置package包名称以及导入依赖的类
package g8.akkahttp.eventsvc

import java.lang.management.ManagementFactory

import akka.actor.ActorSystem
import akka.event.Logging
import akka.http.scaladsl.server.{Directives, Route}
import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport._
import g8.akkahttp.eventsvc.data.access.{DataStoreComponent, MongoDataStoreImpl}

import scala.concurrent.duration.{Duration, MILLISECONDS}

class EventService(system: ActorSystem) extends EventServiceTrait with MongoDataStoreImpl {

  override protected def log      = Logging(system, "service")
  override protected def executor = system.dispatcher
}

trait EventServiceTrait extends BaseComponent with DataStoreComponent with ResponseFactory {
  import Directives._
  import g8.akkahttp.eventsvc.data._
  import io.circe.generic.auto._

  def getStatus: Route = {
    log.info("/event executing")
    complete(Status(Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toString()))
  }

  def readEvent(eventId: String): Route = {
    log.info("/event/read executing")
    complete(s"Requesting an event by Id: $eventId")
  }

  def createEvents(ecr: EventCreationRequest): Route = {
    log.info("/event/create executing")
    sendResponse(dataStore.createEvents(ecr.howMany))
  }

  def getEventsByType(triggerType: Int): Route = {
    log.info("/event/getEventsByType executing")
    sendResponse(
      for {
        events <- dataStore.getEventsByType(triggerType)
      } yield {
        events.map(_.toJson).mkString("[", ",", "]")
      }
    )
  }
} 

//设置package包名称以及导入依赖的类
package org.apache.sparktest
import java.lang.management.ManagementFactory
import akka.actor.Actor
import akka.actor.ActorRef
import akka.actor.ActorSystem
import akka.actor.Props

class Heng(ha: ActorRef) extends Actor {
  def receive = {
    case "start" => ha ! "heng"
    case "ha" =>
      println("?")
      ha ! "heng"
    case _ => println("heng what?")
  }
}
class Ha extends Actor {
  def receive = {
    case "heng" =>
      println("?")
      sender ! "ha"
    case _ => println("ha what?")
  }
}

object HengHa {
  def main(args: Array[String]): Unit = {
    //ActorSystem???????,???1...N???,????application??ActorSystem
    val system = ActorSystem("HengHaSystem")
   //actorOf???Actor,
    val ha = system.actorOf(Props[Ha], name = "ha")
    val heng = system.actorOf(Props(new Heng(ha)), name = "heng")

    //heng ! "start"    
    
    //ManagementFactory.getGarbageCollectorMXBeans.map(_.getCollectionTime).sum
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.jvm

import java.lang.Thread.State._
import java.lang.management.{ManagementFactory, ThreadInfo}


class ContentionSnapshot {
  ManagementFactory.getThreadMXBean.setThreadContentionMonitoringEnabled(true)

  case class Snapshot(
    blockedThreads: Seq[String],
    lockOwners: Seq[String],
    deadlocks: Seq[String])

  private[this] object Blocked {
    def unapply(t: ThreadInfo): Option[ThreadInfo] = {
      t.getThreadState match {
        case BLOCKED | WAITING | TIMED_WAITING => Some(t)
        case _ => None
      }
    }
  }

  def snap(): Snapshot = {
    val bean = ManagementFactory.getThreadMXBean

    val blocked = bean.getThreadInfo(bean.getAllThreadIds, true, true)
                      .filter(_ != null)
                      .collect { case Blocked(info) => info }

    val ownerIds = blocked map(_.getLockOwnerId) filter(_ != -1)
    val owners = if (ownerIds.length == 0) Seq[String]() else
      bean.getThreadInfo(ownerIds.toArray, true, true).map(_.toString).toSeq

    val deadlockThreadIds = bean.findDeadlockedThreads()
    val deadlocks = if (deadlockThreadIds == null) Array.empty[ThreadInfo] else
      deadlockThreadIds.flatMap { id =>
        blocked.find { threadInfo =>
          threadInfo.getThreadId() == id
        }
      }

    Snapshot(
      blockedThreads = blocked.map(_.toString).toSeq,
      lockOwners = owners,
      deadlocks = deadlocks.map(_.toString).toSeq)
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.jvm

import java.lang.management.ManagementFactory
import javax.management.openmbean.CompositeDataSupport
import javax.management.{ObjectName, RuntimeMBeanException}


object Opt {
  private[this] val DiagnosticName =
    ObjectName.getInstance("com.sun.management:type=HotSpotDiagnostic")

  def apply(name: String): Option[String] = try Some {
    val o = ManagementFactory.getPlatformMBeanServer().invoke(
      DiagnosticName, "getVMOption",
      Array(name), Array("java.lang.String"))
    o.asInstanceOf[CompositeDataSupport].get("value").asInstanceOf[String]
  } catch {
    case _: IllegalArgumentException =>
      None
    case rbe: RuntimeMBeanException
    if rbe.getCause.isInstanceOf[IllegalArgumentException] =>
      None
  }
} 

//设置package包名称以及导入依赖的类
package com.twitter.jvm

import java.lang.{Boolean => JBool}
import java.lang.management.ManagementFactory
import javax.management.ObjectName
import org.junit.runner.RunWith
import org.scalatest.FunSuite
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class OptsTest extends FunSuite  {
  test("Opts") {
    if (System.getProperty("java.vm.name").contains("HotSpot")) {
      val DiagnosticName =
        ObjectName.getInstance("com.sun.management:type=HotSpotDiagnostic")

      val originalValue: String = Opt("MaxHeapFreeRatio").getOrElse("100")

      val option = ManagementFactory.getPlatformMBeanServer().invoke(
        DiagnosticName, "getVMOption",
        Array("MaxHeapFreeRatio"),
        Array("java.lang.String"))

      val writable = option.getClass match {
        case clazz: Class[_] if clazz.getCanonicalName == "com.sun.management.VMOption" =>
          clazz.getMethod("isWriteable").invoke(option) match {
            case bool: JBool => bool: Boolean
            case _ => fail()
          }
        case _ => false
      }

      if (writable) {
        ManagementFactory.getPlatformMBeanServer().invoke(
          DiagnosticName, "setVMOption",
          Array("MaxHeapFreeRatio", "99"),
          Array("java.lang.String", "java.lang.String"))

        assert(Opt("MaxHeapFreeRatio") == Some("99"))

        ManagementFactory.getPlatformMBeanServer().invoke(
          DiagnosticName, "setVMOption",
          Array("MaxHeapFreeRatio", originalValue),
          Array("java.lang.String", "java.lang.String"))

        assert(Opt("MaxHeapFreeRatio") == Some(originalValue))

        assert(Opt("NonexistentOption") == None)
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package sekvensa.service.healthcheck

import java.lang.management.ManagementFactory

import akka.event.Logging
import akka.http.scaladsl.server.Directives._
import sekvensa.service.ServiceBase
import sekvensa.service.healthcheck.models.Status

import scala.concurrent.duration._

trait HealthCheckService extends ServiceBase {

  private val pingRoute = path("ping") {
    get {
      logRequest("/ping", Logging.InfoLevel) {
        complete("PONG")
      }
    }
  }

  private val uptimeRoute = path("uptime") {
    get {
      logRequest("/uptime", Logging.InfoLevel) {
        val uptime = Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toSeconds
        complete(Status(uptime))
      }
    }
  }

  val routes = pingRoute ~ uptimeRoute
} 

//设置package包名称以及导入依赖的类
package com.mz.training.health

import java.lang.management.ManagementFactory

import akka.http.scaladsl.server.Directives._

import scala.concurrent.duration._

trait HealthRoutes {

  def healthRoutes = pathPrefix("health") {
    path("ping") {
      get {
          complete("OK")
        }
      } ~ path("uptime") {
      get {
        complete(getUptime.toString)
      }
    }
  }
  
  private def getUptime = Duration(ManagementFactory.getRuntimeMXBean.getUptime, MILLISECONDS).toSeconds
} 

//设置package包名称以及导入依赖的类
package lila.api

import akka.actor._
import java.lang.management.ManagementFactory
import scala.concurrent.duration._

import lila.hub.actorApi.round.NbRounds
import lila.socket.actorApi.NbMembers

private final class KamonPusher(
    countUsers: () => Int
) extends Actor {

  import KamonPusher._

  override def preStart() {
    scheduleTick
  }

  private val threadStats = ManagementFactory.getThreadMXBean
  private val app = lila.common.PlayApp

  private def scheduleTick =
    context.system.scheduler.scheduleOnce(1 second, self, Tick)

  def receive = {

    case NbMembers(nb) =>
      lila.mon.socket.member(nb)

    case NbRounds(nb) =>
      lila.mon.round.actor.count(nb)

    case Tick =>
      lila.mon.jvm.thread(threadStats.getThreadCount)
      lila.mon.jvm.daemon(threadStats.getDaemonThreadCount)
      lila.mon.jvm.uptime(app.uptime.toStandardSeconds.getSeconds)
      lila.mon.user.online(countUsers())
      scheduleTick
  }
}

object KamonPusher {

  private case object Tick

  def start(system: ActorSystem)(instance: => Actor) =
    system.lilaBus.subscribe(system.actorOf(Props(instance)), 'nbMembers, 'nbRounds)
} 

//设置package包名称以及导入依赖的类
package dcos.metronome

import java.lang.management.ManagementFactory

import com.codahale.metrics.MetricRegistry
import com.codahale.metrics.health.HealthCheckRegistry
import com.codahale.metrics.jvm.{ BufferPoolMetricSet, GarbageCollectorMetricSet, MemoryUsageGaugeSet, ThreadStatesGaugeSet }
import mesosphere.marathon.metrics.Metrics

class MetricsModule {

  lazy val healthCheckRegistry: HealthCheckRegistry = new HealthCheckRegistry()

  lazy val metricsRegistry: MetricRegistry = {
    val registry = new MetricRegistry
    registry.register("jvm.gc", new GarbageCollectorMetricSet())
    registry.register("jvm.buffers", new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer))
    registry.register("jvm.memory", new MemoryUsageGaugeSet())
    registry.register("jvm.threads", new ThreadStatesGaugeSet())
    registry
  }

  lazy val metrics = new Metrics(metricsRegistry)
}