diff options
Diffstat (limited to 'kamon-play24/src/test')
7 files changed, 540 insertions, 0 deletions
diff --git a/kamon-play24/src/test/resources/META-INF/aop.xml b/kamon-play24/src/test/resources/META-INF/aop.xml new file mode 100644 index 00000000..2888a31a --- /dev/null +++ b/kamon-play24/src/test/resources/META-INF/aop.xml @@ -0,0 +1,11 @@ +<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd"> + +<aspectj> + <aspects> + <aspect name="kamon.play.instrumentation.FakeRequestIntrumentation"/> + </aspects> + + <weaver> + <include within="play.api..*"/> + </weaver> +</aspectj> diff --git a/kamon-play24/src/test/resources/conf/application.conf b/kamon-play24/src/test/resources/conf/application.conf new file mode 100644 index 00000000..b927087c --- /dev/null +++ b/kamon-play24/src/test/resources/conf/application.conf @@ -0,0 +1,8 @@ +kamon { + play { + include-trace-token-header = true + trace-token-header-name = "X-Trace-Token" + name-generator = kamon.play.DefaultNameGenerator + } +} + diff --git a/kamon-play24/src/test/resources/logback.xml b/kamon-play24/src/test/resources/logback.xml new file mode 100644 index 00000000..c336bbfe --- /dev/null +++ b/kamon-play24/src/test/resources/logback.xml @@ -0,0 +1,12 @@ +<configuration> + <statusListener class="ch.qos.logback.core.status.NopStatusListener"/> + <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> + <encoder> + <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> + </encoder> + </appender> + + <root level="OFF"> + <appender-ref ref="STDOUT"/> + </root> +</configuration>
\ No newline at end of file diff --git a/kamon-play24/src/test/scala/kamon/play/LoggerLikeInstrumentationSpec.scala b/kamon-play24/src/test/scala/kamon/play/LoggerLikeInstrumentationSpec.scala new file mode 100644 index 00000000..408509c5 --- /dev/null +++ b/kamon-play24/src/test/scala/kamon/play/LoggerLikeInstrumentationSpec.scala @@ -0,0 +1,122 @@ +/* ========================================================================================= + * Copyright © 2013-2014 the kamon project <http://kamon.io/> + * + * 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 kamon.play + +import ch.qos.logback.classic.spi.ILoggingEvent +import ch.qos.logback.classic.{ AsyncAppender, LoggerContext } +import ch.qos.logback.core.read.ListAppender +import ch.qos.logback.core.status.NopStatusListener +import kamon.trace.TraceLocal +import kamon.trace.TraceLocal.AvailableToMdc +import org.scalatest.BeforeAndAfter +import org.scalatestplus.play._ +import org.slf4j +import play.api.LoggerLike +import play.api.mvc.Results.Ok +import play.api.mvc._ +import play.api.test.Helpers._ +import play.api.test._ +import scala.concurrent.duration._ + +import scala.concurrent.{ Await, Future } + +class LoggerLikeInstrumentationSpec extends PlaySpec with OneServerPerSuite with BeforeAndAfter { + System.setProperty("config.file", "./kamon-play/src/test/resources/conf/application.conf") + + val executor = scala.concurrent.ExecutionContext.Implicits.global + + val infoMessage = "Info Message" + val headerValue = "My header value" + val otherValue = "My other value" + + val TraceLocalHeaderKey = AvailableToMdc("header") + val TraceLocalOtherKey = AvailableToMdc("other") + + before { + LoggingHandler.startLogging() + } + + after { + LoggingHandler.stopLogging() + } + + implicit override lazy val app = FakeApplication(withRoutes = { + + case ("GET", "/logging") ⇒ + Action.async { + Future { + TraceLocal.store(TraceLocalHeaderKey)(headerValue) + TraceLocal.store(TraceLocalOtherKey)(otherValue) + LoggingHandler.info(infoMessage) + Ok("OK") + }(executor) + } + }) + + "the LoggerLike instrumentation" should { + "allow retrieve a value from the MDC when was created a key of type AvailableToMdc in the current request" in { + LoggingHandler.appenderStart() + + Await.result(route(FakeRequest(GET, "/logging")).get, 500 millis) + + TraceLocal.retrieve(TraceLocalHeaderKey) must be(Some(headerValue)) + TraceLocal.retrieve(TraceLocalOtherKey) must be(Some(otherValue)) + + LoggingHandler.appenderStop() + + headerValue must be(LoggingHandler.getValueFromMDC("header")) + otherValue must be(LoggingHandler.getValueFromMDC("other")) + } + } +} + +object LoggingHandler extends LoggerLike { + + val loggerContext = new LoggerContext() + val rootLogger = loggerContext.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME) + val asyncAppender = new AsyncAppender() + val listAppender = new ListAppender[ILoggingEvent]() + val nopStatusListener = new NopStatusListener() + + override val logger: slf4j.Logger = rootLogger + + def startLogging(): Unit = { + loggerContext.getStatusManager().add(nopStatusListener) + asyncAppender.setContext(loggerContext) + listAppender.setContext(loggerContext) + listAppender.setName("list") + listAppender.start() + } + + def stopLogging(): Unit = { + listAppender.stop() + } + + def appenderStart(): Unit = { + asyncAppender.addAppender(listAppender) + asyncAppender.start() + rootLogger.addAppender(asyncAppender) + } + + def appenderStop(): Unit = { + asyncAppender.stop() + } + + def getValueFromMDC(key: String): String = { + listAppender.list.get(0).getMDCPropertyMap.get(key) + } +} + diff --git a/kamon-play24/src/test/scala/kamon/play/RequestInstrumentationSpec.scala b/kamon-play24/src/test/scala/kamon/play/RequestInstrumentationSpec.scala new file mode 100644 index 00000000..8a3fef7c --- /dev/null +++ b/kamon-play24/src/test/scala/kamon/play/RequestInstrumentationSpec.scala @@ -0,0 +1,265 @@ +/* ========================================================================================= + * Copyright © 2013-2014 the kamon project <http://kamon.io/> + * + * 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 kamon.play + +import javax.inject.Inject + +import kamon.Kamon +import kamon.metric.instrument.CollectionContext +import kamon.play.action.TraceName +import kamon.trace.TraceLocal.HttpContextKey +import kamon.trace.{ Tracer, TraceLocal } +import org.scalatestplus.play._ +import play.api.DefaultGlobal +import play.api.http.{ HttpErrorHandler, Writeable } +import play.api.libs.concurrent.Execution.Implicits.defaultContext +import play.api.libs.ws.WS +import play.api.mvc.Results.Ok +import play.api.mvc._ +import play.api.routing.SimpleRouter +import play.api.test.Helpers._ +import play.api.test._ +import play.core.routing._ +import play.api.http.HttpFilters + +import scala.concurrent.duration._ +import scala.concurrent.{ Await, Future } + +class RequestInstrumentationSpec extends PlaySpec with OneServerPerSuite { + System.setProperty("config.file", "./kamon-play/src/test/resources/conf/application.conf") + + override lazy val port: Port = 19002 + val executor = scala.concurrent.ExecutionContext.Implicits.global + + implicit override lazy val app = FakeApplication(withRoutes = { + + case ("GET", "/async") ⇒ + Action.async { + Future { + Ok("Async.async") + }(executor) + } + case ("GET", "/notFound") ⇒ + Action { + Results.NotFound + } + case ("GET", "/error") ⇒ + Action { + throw new Exception("This page generates an error!") + Ok("This page will generate an error!") + } + case ("GET", "/redirect") ⇒ + Action { + Results.Redirect("/redirected", MOVED_PERMANENTLY) + } + case ("GET", "/default") ⇒ + Action { + Ok("default") + } + case ("GET", "/async-renamed") ⇒ + TraceName("renamed-trace") { + Action.async { + Future { + Ok("Async.async") + }(executor) + } + } + case ("GET", "/retrieve") ⇒ + Action { + Ok("retrieve from TraceLocal") + } + }, additionalConfiguration = Map( + ("application.router", "kamon.play.Routes"), + ("play.http.filters", "kamon.play.TestHttpFilters"), + ("play.http.requestHandler", "play.api.http.DefaultHttpRequestHandler"), + ("logger.root", "OFF"), + ("logger.play", "OFF"), + ("logger.application", "OFF"))) + + val traceTokenValue = "kamon-trace-token-test" + val traceTokenHeaderName = "X-Trace-Token" + val expectedToken = Some(traceTokenValue) + val traceTokenHeader = traceTokenHeaderName -> traceTokenValue + val traceLocalStorageValue = "localStorageValue" + val traceLocalStorageKey = "localStorageKey" + val traceLocalStorageHeader = traceLocalStorageKey -> traceLocalStorageValue + + "the Request instrumentation" should { + "respond to the Async Action with X-Trace-Token" in { + val Some(result) = route(FakeRequest(GET, "/async").withHeaders(traceTokenHeader, traceLocalStorageHeader)) + header(traceTokenHeaderName, result) must be(expectedToken) + } + + "respond to the NotFound Action with X-Trace-Token" in { + val Some(result) = route(FakeRequest(GET, "/notFound").withHeaders(traceTokenHeader)) + header(traceTokenHeaderName, result) must be(expectedToken) + } + + "respond to the Default Action with X-Trace-Token" in { + val Some(result) = route(FakeRequest(GET, "/default").withHeaders(traceTokenHeader)) + header(traceTokenHeaderName, result) must be(expectedToken) + } + + "respond to the Redirect Action with X-Trace-Token" in { + val Some(result) = route(FakeRequest(GET, "/redirect").withHeaders(traceTokenHeader)) + header("Location", result) must be(Some("/redirected")) + header(traceTokenHeaderName, result) must be(expectedToken) + } + + "respond to the Async Action with X-Trace-Token and the renamed trace" in { + val result = Await.result(route(FakeRequest(GET, "/async-renamed").withHeaders(traceTokenHeader)).get, 10 seconds) + Tracer.currentContext.name must be("renamed-trace") + Some(result.header.headers(traceTokenHeaderName)) must be(expectedToken) + } + + "propagate the TraceContext and LocalStorage through of filters in the current request" in { + route(FakeRequest(GET, "/retrieve").withHeaders(traceTokenHeader, traceLocalStorageHeader)) + TraceLocal.retrieve(TraceLocalKey).get must be(traceLocalStorageValue) + } + + "response to the getRouted Action and normalise the current TraceContext name" in { + Await.result(WS.url(s"http://localhost:$port/getRouted").get(), 10 seconds) + Kamon.metrics.find("getRouted.get", "trace") must not be empty + } + + "response to the postRouted Action and normalise the current TraceContext name" in { + Await.result(WS.url(s"http://localhost:$port/postRouted").post("content"), 10 seconds) + Kamon.metrics.find("postRouted.post", "trace") must not be empty + } + + "response to the showRouted Action and normalise the current TraceContext name" in { + Await.result(WS.url(s"http://localhost:$port/showRouted/2").get(), 10 seconds) + Kamon.metrics.find("show.some.id.get", "trace") must not be empty + } + + "record http server metrics for all processed requests" in { + val collectionContext = CollectionContext(100) + Kamon.metrics.find("play-server", "http-server").get.collect(collectionContext) + + for (repetition ← 1 to 10) { + Await.result(route(FakeRequest(GET, "/default").withHeaders(traceTokenHeader)).get, 10 seconds) + } + + for (repetition ← 1 to 5) { + Await.result(route(FakeRequest(GET, "/notFound").withHeaders(traceTokenHeader)).get, 10 seconds) + } + + for (repetition ← 1 to 5) { + Await.result(routeWithOnError(FakeRequest(GET, "/error").withHeaders(traceTokenHeader)).get, 10 seconds) + } + + val snapshot = Kamon.metrics.find("play-server", "http-server").get.collect(collectionContext) + snapshot.counter("GET: /default_200").get.count must be(10) + snapshot.counter("GET: /notFound_404").get.count must be(5) + snapshot.counter("GET: /error_500").get.count must be(5) + snapshot.counter("200").get.count must be(10) + snapshot.counter("404").get.count must be(5) + snapshot.counter("500").get.count must be(5) + } + } + + def routeWithOnError[T](req: Request[T])(implicit w: Writeable[T]): Option[Future[Result]] = { + route(req).map { result ⇒ + result.recoverWith { + case t: Throwable ⇒ DefaultGlobal.onError(req, t) + } + } + } +} + +object TraceLocalKey extends TraceLocal.TraceLocalKey { + type ValueType = String +} + +class TraceLocalFilter extends Filter { + + val traceLocalStorageValue = "localStorageValue" + val traceLocalStorageKey = "localStorageKey" + val traceLocalStorageHeader = traceLocalStorageKey -> traceLocalStorageValue + + override def apply(next: (RequestHeader) ⇒ Future[Result])(header: RequestHeader): Future[Result] = { + Tracer.withContext(Tracer.currentContext) { + + TraceLocal.store(TraceLocalKey)(header.headers.get(traceLocalStorageKey).getOrElse("unknown")) + + next(header).map { + result ⇒ + { + result.withHeaders(traceLocalStorageKey -> TraceLocal.retrieve(TraceLocalKey).get) + } + } + } + } +} + +class TestHttpFilters @Inject() (traceLocalFilter: TraceLocalFilter) extends HttpFilters { + val filters = Seq(traceLocalFilter) +} + +class Routes @Inject() (application: controllers.Application) extends GeneratedRouter with SimpleRouter { + val prefix = "/" + + lazy val defaultPrefix = { + if (prefix.endsWith("/")) "" else "/" + } + + // Gets + private[this] lazy val Application_getRouted = + Route("GET", PathPattern(List(StaticPart(prefix), StaticPart(defaultPrefix), StaticPart("getRouted")))) + + private[this] lazy val Application_show = + Route("GET", PathPattern(List(StaticPart(prefix), StaticPart(defaultPrefix), StaticPart("showRouted/"), DynamicPart("id", """[^/]+""", encodeable = true)))) + + //Posts + private[this] lazy val Application_postRouted = + Route("POST", PathPattern(List(StaticPart(prefix), StaticPart(defaultPrefix), StaticPart("postRouted")))) + + def routes: PartialFunction[RequestHeader, Handler] = { + case Application_getRouted(params) ⇒ call { + createInvoker(application.getRouted, + HandlerDef(this.getClass.getClassLoader, "", "controllers.Application", "getRouted", Nil, "GET", """some comment""", prefix + """getRouted""")).call(application.getRouted) + } + case Application_postRouted(params) ⇒ call { + createInvoker(application.postRouted, + HandlerDef(this.getClass.getClassLoader, "", "controllers.Application", "postRouted", Nil, "POST", """some comment""", prefix + """postRouted""")).call(application.postRouted) + } + case Application_show(params) ⇒ call(params.fromPath[Int]("id", None)) { (id) ⇒ + createInvoker(application.showRouted(id), + HandlerDef(this.getClass.getClassLoader, "", "controllers.Application", "showRouted", Seq(classOf[Int]), "GET", """""", prefix + """show/some/$id<[^/]+>""")).call(application.showRouted(id)) + } + } + + override def errorHandler: HttpErrorHandler = new HttpErrorHandler() { + override def onClientError(request: RequestHeader, statusCode: Int, message: String): Future[Result] = Future.successful(Results.InternalServerError) + override def onServerError(request: RequestHeader, exception: Throwable): Future[Result] = Future.successful(Results.InternalServerError) + } +} + +object controllers { + import play.api.mvc._ + + class Application extends Controller { + val postRouted = Action { + Ok("invoked postRouted") + } + val getRouted = Action { + Ok("invoked getRouted") + } + def showRouted(id: Int) = Action { + Ok("invoked show with: " + id) + } + } +}
\ No newline at end of file diff --git a/kamon-play24/src/test/scala/kamon/play/WSInstrumentationSpec.scala b/kamon-play24/src/test/scala/kamon/play/WSInstrumentationSpec.scala new file mode 100644 index 00000000..11d3133c --- /dev/null +++ b/kamon-play24/src/test/scala/kamon/play/WSInstrumentationSpec.scala @@ -0,0 +1,95 @@ +/* =================================================== + * Copyright © 2013-2014 the kamon project <http://kamon.io/> + * + * 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 kamon.play + +import kamon.metric.{ Entity, EntitySnapshot, TraceMetrics } +import kamon.trace.{ Tracer, TraceContext, SegmentCategory } +import org.scalatest.{ Matchers, WordSpecLike } +import org.scalatestplus.play.OneServerPerSuite +import play.api.libs.ws.WS +import play.api.mvc.Action +import play.api.mvc.Results.Ok +import play.api.test.Helpers._ +import play.api.test._ + +import scala.concurrent.Await +import scala.concurrent.duration._ + +class WSInstrumentationSpec extends WordSpecLike with Matchers with OneServerPerSuite { + System.setProperty("config.file", "./kamon-play/src/test/resources/conf/application.conf") + + override lazy val port: Port = 19003 + implicit override lazy val app = FakeApplication(withRoutes = { + case ("GET", "/async") ⇒ Action { Ok("ok") } + case ("GET", "/outside") ⇒ Action { Ok("ok") } + case ("GET", "/inside") ⇒ callWSinsideController(s"http://localhost:$port/async") + }) + + "the WS instrumentation" should { + "propagate the TraceContext inside an Action and complete the WS request" in { + Await.result(route(FakeRequest(GET, "/inside")).get, 10 seconds) + + val snapshot = takeSnapshotOf("GET: /inside", "trace") + snapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1) + + val segmentMetricsSnapshot = takeSnapshotOf(s"http://localhost:$port/async", "trace-segment", + tags = Map( + "trace" -> "GET: /inside", + "category" -> SegmentCategory.HttpClient, + "library" -> Play.SegmentLibraryName)) + + segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1) + } + + "propagate the TraceContext outside an Action and complete the WS request" in { + Tracer.withContext(newContext("trace-outside-action")) { + Await.result(WS.url(s"http://localhost:$port/outside").get(), 10 seconds) + Tracer.currentContext.finish() + } + + val snapshot = takeSnapshotOf("trace-outside-action", "trace") + snapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1) + + val segmentMetricsSnapshot = takeSnapshotOf(s"http://localhost:$port/outside", "trace-segment", + tags = Map( + "trace" -> "trace-outside-action", + "category" -> SegmentCategory.HttpClient, + "library" -> Play.SegmentLibraryName)) + + segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1) + } + } + + lazy val collectionContext = Kamon.metrics.buildDefaultCollectionContext + + def newContext(name: String): TraceContext = + Kamon.tracer.newContext(name) + + def takeSnapshotOf(name: String, category: String, tags: Map[String, String] = Map.empty): EntitySnapshot = { + val recorder = Kamon.metrics.find(Entity(name, category, tags)).get + recorder.collect(collectionContext) + } + + def callWSinsideController(url: String) = Action.async { + import play.api.Play.current + import play.api.libs.concurrent.Execution.Implicits.defaultContext + + WS.url(url).get().map { response ⇒ + Ok("Ok") + } + } +}
\ No newline at end of file diff --git a/kamon-play24/src/test/scala/kamon/play/instrumentation/FakeRequestIntrumentation.scala b/kamon-play24/src/test/scala/kamon/play/instrumentation/FakeRequestIntrumentation.scala new file mode 100644 index 00000000..10e285db --- /dev/null +++ b/kamon-play24/src/test/scala/kamon/play/instrumentation/FakeRequestIntrumentation.scala @@ -0,0 +1,27 @@ +/* =================================================== + * Copyright © 2013-2014 the kamon project <http://kamon.io/> + * + * 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 kamon.play.instrumentation + +import org.aspectj.lang.annotation.{ DeclareMixin, Aspect } +import kamon.trace.TraceContextAware + +@Aspect +class FakeRequestIntrumentation { + + @DeclareMixin("play.api.test.FakeRequest") + def mixinContextAwareNewRequest: TraceContextAware = TraceContextAware.default +} |