MetricReporter.scala

import java.net.InetSocketAddress
import java.util.concurrent.TimeUnit

import com.codahale.metrics.graphite.{GraphiteReporter, Graphite}
import com.codahale.metrics.{JmxReporter, MetricRegistry, Slf4jReporter}
import org.slf4j.LoggerFactory
import play.api.libs.concurrent.Akka
import services.LogIt
import scala.concurrent.duration._

import play.api.Play.current
import scala.concurrent.ExecutionContext.Implicits.global

/**
 * Created by slovic on 11.09.15.
 */
class MetricsReporter(options: MetricsOptions, registry: MetricRegistry) {
  val logger = LoggerFactory.getLogger(classOf[MetricsReporter])
  val log = LogIt("MetricsReporter")

  lazy val slf4jReporter = Slf4jReporter.forRegistry(registry)
    .outputTo(logger)
    .convertRatesTo(TimeUnit.SECONDS)
    .convertDurationsTo(TimeUnit.MILLISECONDS)
    .build()

  lazy val jmxReporter = JmxReporter.forRegistry(registry).build()

  lazy val graphite = new Graphite(new InetSocketAddress(options.graphiteHost, options.graphitePort))

  lazy val graphiteReporter = GraphiteReporter.forRegistry(registry)
    .convertRatesTo(TimeUnit.SECONDS)
    .convertDurationsTo(TimeUnit.MILLISECONDS)
    .build(graphite)


  def start(): Unit = {
    log.info("Starting metrics configuration...")
    if (options.loggingMetricsEnabled) {
      logger.info("Starting metrics logging...")
      slf4jReporter.start(options.loggingIntervalSecs, TimeUnit.SECONDS)
    }

    if (options.jmxEnable) {
      log.info(s"Starting metrics JMX reporter on ${System.getProperty("java.rmi.server.hostname")}:${System.getProperty("com.sun.management.jmxremote.port")} ...")
      jmxReporter.start()
    }

    if (options.graphiteEnable) {
      log.info(s"Starting metrics Graphite reporter to ${options.graphiteHost}:${options.graphitePort}")
      Akka.system.scheduler.schedule (
        options.graphiteIntervalSecs seconds,
        options.graphiteIntervalSecs seconds,
        new Runnable {
          override def run(): Unit = {
            log.debug("właśnie wysyłam")
            graphiteReporter.report()
          }
        }
      )
    }
  }

  def stop() {
    log.info("Shutting down reporters...")
    if (options.loggingMetricsEnabled) slf4jReporter.stop()
    if (options.jmxEnable) jmxReporter.stop()
    if (options.graphiteEnable) graphiteReporter.stop()
  }
}


/**
 * Options for configuring metrics and reporters.
 * Easiest way to get started is using a Typesafe config:
    metrics.prefix = "default.metrics"
    metrics.logs.enable = false
    metrics.logs.interwal = 5m
    metrics.jmx.enable = true
    metrics.graphite.enable = true
    metrics.graphite.host = "my.graphite.host"
    metrics.graphite.port = 2003
    metrics.graphite.interval = 60s

    and then create it from config like that:
    MetricsOptions.fromConfig(Play.configuration.getConfig("metrics"))
 */
case class MetricsOptions(
  prefix: String,
  loggingMetricsEnabled: Boolean,
  jmxEnable: Boolean,
  graphiteEnable: Boolean,
  graphiteHost: String,
  graphitePort: Int,
  graphiteIntervalSecs: Int,
  loggingIntervalSecs: Int
)

object MetricsOptions {
  def fromConfig(conf:Config):MetricsOptions = {
    //config with defaults
    val cwd = conf.withFallback(defaultConfig)

    new MetricsOptions(
      cwd.getString  ("prefix"),
      cwd.getBoolean ("logs.enable"),
      cwd.getBoolean ("jmx.enable"),
      cwd.getBoolean ("graphite.enable"),
      cwd.getString  ("graphite.host"),
      cwd.getInt     ("graphite.port"),
      cwd.getDuration("graphite.interval", TimeUnit.SECONDS).toInt,
      cwd.getDuration("logs.interwal", TimeUnit.SECONDS).toInt
    )
  }

  def fromConfig(conf:Option[Configuration]):MetricsOptions = {
    //config with defaults
    val cwd = conf
        .map(_.underlying)
        .getOrElse(defaultConfig)

    MetricsOptions.fromConfig(cwd)
  }

  val defaultConfig = {
    val m:java.util.Map[String, _ <: AnyRef] = Map(
      "prefix"             -> "default.metrics",
      "logs.enable"        -> Boolean.box(true),
      "jmx.enable"         -> Boolean.box(true),
      "graphite.enable"    -> Boolean.box(false),
      "graphite.host"      -> "localhost",
      "graphite.port"      -> Int.box(2003),
      "graphite.interval"  -> "60s",
      "logs.interwal"      -> "300s"
    ).asJava
    ConfigFactory.parseMap(m)
  }
}