Split dropwizard v4 and v5 (#85)

* Split dropwizard v4 and v5

* Ignre dimensions and log warning

Author: RustedBones

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Split dropwizard v4 and v5. v4 being the default.
 - Fix bug when HttpEntity.Default is used with HTTP/1.0 protocol
 
 ## 1.4.1 (2020-12-14)

README.md

@@ -233,18 +233,21 @@ See datadog's [documentation](https://github.com/dataDog/java-dogstatsd-client)
 | connections        | connections        |
 | connections active | connections.active |
 
-**Important**: The `DropwizardRegistry` works with tags. This feature is only supported since dropwizard `v5`. 
+**Important**: The `DropwizardRegistry` does not support labels.
+This feature will be available with dropwizard `v5`, which development is paused at the moment.
 
 Add to your `build.sbt`:
 
 ```scala
 libraryDependencies += "fr.davit" %% "akka-http-metrics-dropwizard" % <version>
+// or for dropwizard v5
+libraryDependencies += "fr.davit" %% "akka-http-metrics-dropwizard-v5" % <version>
 ```
 
 Create your registry
 
 ```scala
-import io.dropwizard.metrics5.MetricRegistry
+import com.codahale.metrics.MetricRegistry
 import fr.davit.akka.http.metrics.core.HttpMetricsSettings
 import fr.davit.akka.http.metrics.dropwizard.{DropwizardRegistry, DropwizardSettings}
 
@@ -263,15 +266,15 @@ val route = (get & path("metrics"))(metrics(registry))
 ```
 
 All metrics from the dropwizard metrics registry will be exposed.
-You can find some external exporters [here](https://github.com/dropwizard/metrics/tree/5.0-development). For instance,
+You can find some external exporters [here](https://github.com/dropwizard/metrics/). For instance,
 to expose some JVM metrics, you have to add the dedicated dependency and register the metrics set into your collector registry:
 
 ```sbt
-libraryDependencies += "io.dropwizard.metrics5" % "metrics-jvm" % <version>
+libraryDependencies += "com.codahale.metrics" % "metrics-jvm" % <version>
 ```
 
 ```scala
-import io.dropwizard.metrics5.jvm._
+import com.codahale.metrics.jvm._
 
 val dropwizard: MetricRegistry = ... // your dropwizard registry
 dropwizard.register("jvm.gc", new GarbageCollectorMetricSet())

build.sbt

@@ -23,7 +23,7 @@ lazy val commonSettings = Defaults.itSettings ++
     Seq(
       organization := "fr.davit",
       organizationName := "Michel Davit",
-      version := "1.4.2-SNAPSHOT",
+      version := "1.5.0-SNAPSHOT",
       crossScalaVersions := (ThisBuild / crossScalaVersions).value,
       scalaVersion := crossScalaVersions.value.head,
       scalacOptions ~= filterScalacOptions,
@@ -102,6 +102,7 @@ lazy val `akka-http-metrics-dropwizard` = (project in file("dropwizard"))
     libraryDependencies ++= Seq(
       Dependencies.dropwizardCore,
       Dependencies.dropwizardJson,
+      Dependencies.scalaLogging,
       Dependencies.Provided.akkaStream,
       Dependencies.Test.akkaHttpJson,
       Dependencies.Test.akkaHttpTestkit,
@@ -115,6 +116,27 @@ lazy val `akka-http-metrics-dropwizard` = (project in file("dropwizard"))
     )
   )
 
+lazy val `akka-http-metrics-dropwizard-v5` = (project in file("dropwizard-v5"))
+  .configs(IntegrationTest)
+  .dependsOn(`akka-http-metrics-core`)
+  .settings(commonSettings: _*)
+  .settings(
+    libraryDependencies ++= Seq(
+      Dependencies.dropwizardV5Core,
+      Dependencies.dropwizardV5Json,
+      Dependencies.Provided.akkaStream,
+      Dependencies.Test.akkaHttpJson,
+      Dependencies.Test.akkaHttpTestkit,
+      Dependencies.Test.akkaSlf4j,
+      Dependencies.Test.akkaStreamTestkit,
+      Dependencies.Test.akkaTestkit,
+      Dependencies.Test.dropwizardV5Jvm,
+      Dependencies.Test.logback,
+      Dependencies.Test.scalaCollectionCompat,
+      Dependencies.Test.scalaTest
+    )
+  )
+
 lazy val `akka-http-metrics-graphite` = (project in file("graphite"))
   .configs(IntegrationTest)
   .dependsOn(`akka-http-metrics-core`)

dropwizard-v5/src/it/resources/application.conf

@@ -0,0 +1,5 @@
+akka {
+  loggers = ["akka.event.slf4j.Slf4jLogger"]
+  loglevel = "DEBUG"
+  logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"
+}

dropwizard-v5/src/it/resources/logback-test.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration debug="false">
+    <appender name="file" class="ch.qos.logback.core.FileAppender">
+        <file>./target/akka-http-metrics-dropwizard.it-test.log</file>
+        <append>false</append>
+        <encoder>
+            <pattern>%date{HH:mm:ss} %-5level %logger{0} {%class %method} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="DEBUG">
+        <appender-ref ref="file"/>
+    </root>
+</configuration>

dropwizard-v5/src/it/scala/fr/davit/akka/http/metrics/dropwizard/DropwizardMetricsItSpec.scala

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2019 Michel Davit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fr.davit.akka.http.metrics.dropwizard
+
+import java.util.concurrent.TimeUnit
+
+import akka.actor.ActorSystem
+import akka.http.scaladsl.Http
+import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
+import akka.http.scaladsl.model.{HttpRequest, StatusCodes, Uri}
+import akka.http.scaladsl.server.Directives._
+import akka.http.scaladsl.server.Route
+import akka.http.scaladsl.unmarshalling.Unmarshal
+import akka.testkit.TestKit
+import fr.davit.akka.http.metrics.core.HttpMetrics._
+import fr.davit.akka.http.metrics.core.scaladsl.server.HttpMetricsDirectives._
+import fr.davit.akka.http.metrics.dropwizard.marshalling.DropwizardMarshallers._
+import io.dropwizard.metrics5.MetricRegistry
+import io.dropwizard.metrics5.jvm.{CachedThreadStatesGaugeSet, GarbageCollectorMetricSet, MemoryUsageGaugeSet}
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpecLike
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.time.{Millis, Seconds, Span}
+import spray.json.{DefaultJsonProtocol, JsValue}
+
+import scala.concurrent.duration._
+
+class DropwizardMetricsItSpec
+    extends TestKit(ActorSystem("DropwizardMetricsItSpec"))
+    with AnyFlatSpecLike
+    with Matchers
+    with ScalaFutures
+    with BeforeAndAfterAll
+    with SprayJsonSupport
+    with DefaultJsonProtocol {
+
+  implicit val defaultPatience = PatienceConfig(timeout = Span(10, Seconds), interval = Span(500, Millis))
+
+  private case class JsonResponse(metrics: Map[String, JsValue])
+  implicit private val metricsFormat = jsonFormat1(JsonResponse)
+
+  override def afterAll(): Unit = {
+    Http().shutdownAllConnectionPools()
+    TestKit.shutdownActorSystem(system)
+  }
+
+  "DropwizardMetrics" should "expose external metrics" in {
+    val settings                   = DropwizardSettings.default
+    val dropwizard: MetricRegistry = new MetricRegistry()
+    dropwizard.register("jvm.gc", new GarbageCollectorMetricSet())
+    dropwizard.register("jvm.threads", new CachedThreadStatesGaugeSet(10, TimeUnit.SECONDS))
+    dropwizard.register("jvm.memory", new MemoryUsageGaugeSet())
+
+    val registry = DropwizardRegistry(dropwizard, settings)
+
+    val route: Route = (get & path("metrics"))(metrics(registry))
+
+    val binding = Http()
+      .newMeteredServerAt("localhost", 0, registry)
+      .bindFlow(route)
+      .futureValue
+
+    val uri = Uri("/metrics")
+      .withScheme("http")
+      .withAuthority(binding.localAddress.getHostString, binding.localAddress.getPort)
+    val request = HttpRequest().withUri(uri)
+
+    val response = Http()
+      .singleRequest(request)
+      .futureValue
+
+    response.status shouldBe StatusCodes.OK
+    val body = Unmarshal(response).to[JsonResponse].futureValue
+
+    body.metrics.keys.filter(_.startsWith("jvm.gc")) should not be empty
+    body.metrics.keys.filter(_.startsWith("jvm.memory")) should not be empty
+    body.metrics.keys.filter(_.startsWith("jvm.threads")) should not be empty
+
+    binding.terminate(30.seconds).futureValue
+  }
+}

dropwizard-v5/src/main/scala/fr/davit/akka/http/metrics/dropwizard/DropwizardMetrics.scala

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2019 Michel Davit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fr.davit.akka.http.metrics.dropwizard
+
+import fr.davit.akka.http.metrics.core.{Counter, Dimension, Gauge, Histogram, Timer}
+import io.dropwizard.metrics5.{MetricName, MetricRegistry}
+
+import scala.concurrent.duration.FiniteDuration
+
+object DropwizardMetrics {
+
+  implicit class RichMetricsName(val metricName: MetricName) extends AnyVal {
+
+    def tagged(dimensions: Seq[Dimension]): MetricName =
+      metricName.tagged(dimensions.flatMap(d => Seq(d.key, d.value)): _*)
+
+  }
+}
+
+abstract class DropwizardMetrics(namespace: String, name: String) {
+  protected lazy val metricName: MetricName = MetricName.build(namespace, name)
+}
+
+class DropwizardCounter(namespace: String, name: String)(implicit registry: MetricRegistry)
+    extends DropwizardMetrics(namespace, name)
+    with Counter {
+
+  import DropwizardMetrics._
+
+  override def inc(dimensions: Seq[Dimension] = Seq.empty): Unit = {
+    registry.counter(metricName.tagged(dimensions)).inc()
+  }
+}
+
+class DropwizardGauge(namespace: String, name: String)(implicit registry: MetricRegistry)
+    extends DropwizardMetrics(namespace, name)
+    with Gauge {
+
+  import DropwizardMetrics._
+
+  override def inc(dimensions: Seq[Dimension] = Seq.empty): Unit = {
+    registry.counter(metricName.tagged(dimensions)).inc()
+  }
+
+  override def dec(dimensions: Seq[Dimension] = Seq.empty): Unit = {
+    registry.counter(metricName.tagged(dimensions)).dec()
+  }
+}
+
+class DropwizardTimer(namespace: String, name: String)(implicit registry: MetricRegistry)
+    extends DropwizardMetrics(namespace, name)
+    with Timer {
+
+  import DropwizardMetrics._
+
+  override def observe(duration: FiniteDuration, dimensions: Seq[Dimension] = Seq.empty): Unit = {
+    registry.timer(metricName.tagged(dimensions)).update(duration.length, duration.unit)
+  }
+}
+
+class DropwizardHistogram(namespace: String, name: String)(implicit registry: MetricRegistry)
+    extends DropwizardMetrics(namespace, name)
+    with Histogram {
+
+  import DropwizardMetrics._
+
+  override def update[T](value: T, dimensions: Seq[Dimension] = Seq.empty)(implicit numeric: Numeric[T]): Unit = {
+    registry.histogram(metricName.tagged(dimensions)).update(numeric.toLong(value))
+  }
+}

dropwizard-v5/src/main/scala/fr/davit/akka/http/metrics/dropwizard/DropwizardRegistry.scala

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2019 Michel Davit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fr.davit.akka.http.metrics.dropwizard
+
+import fr.davit.akka.http.metrics.core.{HttpMetricsSettings, _}
+import io.dropwizard.metrics5.MetricRegistry
+
+object DropwizardRegistry {
+
+  def apply(
+      registry: MetricRegistry = new MetricRegistry(),
+      settings: HttpMetricsSettings = DropwizardSettings.default
+  ): DropwizardRegistry = {
+    new DropwizardRegistry(settings)(registry)
+  }
+}
+
+class DropwizardRegistry(settings: HttpMetricsSettings)(implicit val underlying: MetricRegistry)
+    extends HttpMetricsRegistry(settings) {
+
+  lazy val requests: Counter         = new DropwizardCounter(settings.namespace, settings.metricsNames.requests)
+  lazy val requestsActive: Gauge     = new DropwizardGauge(settings.namespace, settings.metricsNames.requestsActive)
+  lazy val requestsFailures: Counter = new DropwizardCounter(settings.namespace, settings.metricsNames.requestsFailures)
+  lazy val requestsSize: Histogram   = new DropwizardHistogram(settings.namespace, settings.metricsNames.requestsSize)
+  lazy val responses: Counter        = new DropwizardCounter(settings.namespace, settings.metricsNames.responses)
+  lazy val responsesErrors: Counter  = new DropwizardCounter(settings.namespace, settings.metricsNames.responsesErrors)
+  lazy val responsesDuration: Timer  = new DropwizardTimer(settings.namespace, settings.metricsNames.responsesDuration)
+  lazy val responsesSize: Histogram  = new DropwizardHistogram(settings.namespace, settings.metricsNames.responsesSize)
+  lazy val connections: Counter      = new DropwizardCounter(settings.namespace, settings.metricsNames.connections)
+  lazy val connectionsActive: Gauge  = new DropwizardGauge(settings.namespace, settings.metricsNames.connectionsActive)
+}