From 84a67e00581aecb0a7d440a8730834944e4829eb Mon Sep 17 00:00:00 2001 From: John St John Date: Thu, 5 Oct 2017 15:39:30 -0700 Subject: cleanup logging, remove old tracing, use new tracing library --- build.sbt | 11 +- src/main/scala/xyz/driver/core/app.scala | 129 +++++++++++---------- .../xyz/driver/core/logging/DriverLayout.scala | 58 --------- src/main/scala/xyz/driver/core/rest.scala | 8 +- ...ceptionLoggingSizedBufferingTraceConsumer.scala | 35 ------ .../driver/core/trace/GoogleServiceTracer.scala | 14 --- .../driver/core/trace/GoogleStackdriverTrace.scala | 56 --------- .../trace/GoogleStackdriverTraceWithConsumer.scala | 95 --------------- .../scala/xyz/driver/core/trace/LoggingTrace.scala | 27 ----- .../driver/core/trace/LoggingTraceConsumer.scala | 11 -- .../xyz/driver/core/trace/ServiceTracer.scala | 19 --- .../core/trace/SimpleSpanContextHandler.scala | 17 --- .../xyz/driver/core/trace/UnitTraceSizer.scala | 7 -- src/main/scala/xyz/driver/core/trace/package.scala | 6 - src/test/scala/xyz/driver/core/AuthTest.scala | 3 +- src/test/scala/xyz/driver/core/MessagesTest.scala | 2 +- 16 files changed, 74 insertions(+), 424 deletions(-) delete mode 100644 src/main/scala/xyz/driver/core/logging/DriverLayout.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/ExceptionLoggingSizedBufferingTraceConsumer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/GoogleServiceTracer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/GoogleStackdriverTrace.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/GoogleStackdriverTraceWithConsumer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/LoggingTrace.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/LoggingTraceConsumer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/ServiceTracer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/SimpleSpanContextHandler.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/UnitTraceSizer.scala delete mode 100644 src/main/scala/xyz/driver/core/trace/package.scala diff --git a/build.sbt b/build.sbt index b95e1a5..2770f58 100644 --- a/build.sbt +++ b/build.sbt @@ -2,12 +2,12 @@ import sbt._ import Keys._ lazy val akkaHttpV = "10.0.10" -lazy val googleTraceV = "0.5.0" lazy val core = (project in file(".")) .driverLibrary("core") .settings(lintingSettings ++ formatSettings) .settings(libraryDependencies ++= Seq( + "xyz.driver" %% "tracing" % "0.0.2", "com.typesafe.akka" %% "akka-http-core" % akkaHttpV, "com.typesafe.akka" %% "akka-http-spray-json" % akkaHttpV, "com.typesafe.akka" %% "akka-http-testkit" % akkaHttpV, @@ -22,12 +22,5 @@ lazy val core = (project in file(".")) "com.typesafe.slick" %% "slick" % "3.2.1", "com.typesafe" % "config" % "1.2.1", "com.typesafe.scala-logging" %% "scala-logging" % "3.5.0", - "ch.qos.logback" % "logback-classic" % "1.1.11", - "com.google.cloud.trace" % "core" % googleTraceV, - "com.google.cloud.trace" % "logging-service" % googleTraceV, - "com.google.cloud.trace" % "trace-grpc-api-service" % googleTraceV, - // the following version of netty boringssl (or maybe greater) is/was needed to avoid Jetty ALPN/NPN - // config errors w/ SSL in google libs. Before removing test that tracing posts to google - // in a service that uses this library. - "io.netty" % "netty-tcnative-boringssl-static" % "2.0.3.Final" + "ch.qos.logback" % "logback-classic" % "1.1.11" )) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index a7ba7aa..82471b2 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -23,7 +23,8 @@ import xyz.driver.core.rest._ import xyz.driver.core.stats.SystemStats import xyz.driver.core.time.Time import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider} -import xyz.driver.core.trace.{LoggingTrace, ServiceTracer} +import xyz.driver.tracing._ +import xyz.driver.tracing.TracingDirectives._ import scala.compat.Platform.ConcurrentModificationException import scala.concurrent.duration._ @@ -36,25 +37,25 @@ import scalaz.syntax.equal._ object app { - class DriverApp(appName: String, - version: String, - gitHash: String, - modules: Seq[Module], - time: TimeProvider = new SystemTimeProvider(), - log: Logger = Logger(LoggerFactory.getLogger(classOf[DriverApp])), - config: Config = core.config.loadDefaultConfig, - interface: String = "::0", - baseUrl: String = "localhost:8080", - scheme: String = "http", - port: Int = 8080, - tracer: Option[ServiceTracer] = None)(implicit actorSystem: ActorSystem, - executionContext: ExecutionContext) { + class DriverApp( + appName: String, + version: String, + gitHash: String, + modules: Seq[Module], + time: TimeProvider = new SystemTimeProvider(), + log: Logger = Logger(LoggerFactory.getLogger(classOf[DriverApp])), + config: Config = core.config.loadDefaultConfig, + interface: String = "::0", + baseUrl: String = "localhost:8080", + scheme: String = "http", + port: Int = 8080, + tracer: Option[Tracer] = None)(implicit actorSystem: ActorSystem, executionContext: ExecutionContext) { implicit private lazy val materializer = ActorMaterializer()(actorSystem) private lazy val http = Http()(actorSystem) val appEnvironment = config.getString("application.environment") val serviceTracer = - tracer.getOrElse(new LoggingTrace(appName, config.getString("application.environment"), log, 1024, 15)) + tracer.getOrElse(new LoggingTracer(s => log.debug(s))) def run(): Unit = { activateServices(modules) scheduleServicesDeactivation(modules) @@ -64,8 +65,8 @@ object app { def stop(): Unit = { http.shutdownAllConnectionPools().onComplete { _ => - val _ = actorSystem.terminate() - serviceTracer.flush() // flush out any remaining traces from the buffer + serviceTracer.close() // flush out any remaining traces from the buffer + val _ = actorSystem.terminate() val terminated = Await.result(actorSystem.whenTerminated, 30.seconds) val addressTerminated = if (terminated.addressTerminated) "is" else "is not" Console.print(s"${this.getClass.getName} App $addressTerminated stopped ") @@ -88,15 +89,15 @@ object app { "Access-Control-Allow-Headers", "Server", "Date", - ContextHeaders.TrackingIdHeader, + TraceHeaderName, + SpanHeaderName, ContextHeaders.StacktraceHeader, ContextHeaders.AuthenticationTokenHeader, "X-Frame-Options", "X-Content-Type-Options", "Strict-Transport-Security", AuthProvider.SetAuthenticationTokenHeader, - AuthProvider.SetPermissionsTokenHeader, - trace.TracingHeaderKey + AuthProvider.SetPermissionsTokenHeader ) private def allowOrigin(originHeader: Option[Origin]) = @@ -136,52 +137,52 @@ object app { val _ = Future { http.bindAndHandle( route2HandlerFlow(extractHost { origin => - extractClientIP { ip => - optionalHeaderValueByType[Origin](()) { originHeader => - { ctx => - val traceSpan = serviceTracer.startSpan(ctx.request) - val tracingHeader = traceSpan.header - val trackingId = rest.extractTrackingId(ctx.request) - MDC.put("trackingId", trackingId) - - val updatedStacktrace = (rest.extractStacktrace(ctx.request) ++ Array(appName)).mkString("->") - MDC.put("stack", updatedStacktrace) - - storeRequestContextToMdc(ctx.request, origin, ip) - - def requestLogging: Future[Unit] = Future { - log.info( - s"""Received request {"method":"${ctx.request.method.value}","url": "${ctx.request.uri}"}""") - } - - val contextWithTrackingId = - ctx.withRequest( - ctx.request - .addHeader(tracingHeader) - .addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId)) - .addHeader(RawHeader(ContextHeaders.StacktraceHeader, updatedStacktrace))) - - handleExceptions(ExceptionHandler(exceptionHandler))({ - c => - requestLogging.flatMap { _ => - val trackingHeader = RawHeader(ContextHeaders.TrackingIdHeader, trackingId) - - val responseHeaders = List[HttpHeader]( - trackingHeader, - tracingHeader, - allowOrigin(originHeader), - `Access-Control-Allow-Headers`(allowedHeaders: _*), - `Access-Control-Expose-Headers`(allowedHeaders: _*) - ) - - respondWithHeaders(responseHeaders) { - modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) - }(c) + trace(serviceTracer) { + extractClientIP { + ip => + optionalHeaderValueByType[Origin](()) { + originHeader => + { + ctx => + val trackingId = rest.extractTrackingId(ctx.request) + MDC.put("trackingId", trackingId) + + val updatedStacktrace = + (rest.extractStacktrace(ctx.request) ++ Array(appName)).mkString("->") + MDC.put("stack", updatedStacktrace) + + storeRequestContextToMdc(ctx.request, origin, ip) + + def requestLogging: Future[Unit] = Future { + log.info( + s"""Received request {"method":"${ctx.request.method.value}","url": "${ctx.request.uri}"}""") + } + + val contextWithTrackingId = + ctx.withRequest( + ctx.request + .addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId)) + .addHeader(RawHeader(ContextHeaders.StacktraceHeader, updatedStacktrace))) + + handleExceptions(ExceptionHandler(exceptionHandler))({ + c => + requestLogging.flatMap { _ => + val trackingHeader = RawHeader(ContextHeaders.TrackingIdHeader, trackingId) + + val responseHeaders = List[HttpHeader]( + trackingHeader, + allowOrigin(originHeader), + `Access-Control-Allow-Headers`(allowedHeaders: _*), + `Access-Control-Expose-Headers`(allowedHeaders: _*) + ) + + respondWithHeaders(responseHeaders) { + modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) + }(c) + } + })(contextWithTrackingId) } - })(contextWithTrackingId).andThen { - case _ => serviceTracer.endSpan(traceSpan) } - } } } }), diff --git a/src/main/scala/xyz/driver/core/logging/DriverLayout.scala b/src/main/scala/xyz/driver/core/logging/DriverLayout.scala deleted file mode 100644 index 5e6c7df..0000000 --- a/src/main/scala/xyz/driver/core/logging/DriverLayout.scala +++ /dev/null @@ -1,58 +0,0 @@ -package xyz.driver.core -package logging - -import java.text.SimpleDateFormat -import java.util.Date - -import ch.qos.logback.classic.spi.ILoggingEvent -import ch.qos.logback.core.LayoutBase -import org.apache.commons.lang3.StringUtils - -class DriverLayout extends LayoutBase[ILoggingEvent] { - import scala.collection.JavaConverters._ - - private val FieldSeparator = "=" - private val DateFormatString = "MM/dd/yyyy HH:mm:ss" - private val newline = System.getProperty("line.separator") - private val IgnoredClassesInStack = Set("org.apache.catalina", "org.apache.coyote", "sun.reflect", "javax.servlet") - - override def doLayout(loggingEvent: ILoggingEvent): String = { - - val date = new SimpleDateFormat(DateFormatString).format(new Date(loggingEvent.getTimeStamp)) - val level = StringUtils.rightPad(loggingEvent.getLevel.toString, 5) - - val message = new StringBuilder(s"$date [$level] - ${loggingEvent.getMessage}$newline") - - logContext(message, loggingEvent) - - Option(loggingEvent.getCallerData) foreach { stacktrace => - val stacktraceLength = stacktrace.length - - if (stacktraceLength > 0) { - val location = stacktrace.head - - val _ = message - .append(s"Location: ${location.getClassName}.${location.getMethodName}:${location.getLineNumber}$newline") - .append(s"Exception: ${location.toString}$newline") - - if (stacktraceLength > 1) { - message.append(stacktrace.tail.filterNot { e => - IgnoredClassesInStack.forall(ignored => !e.getClassName.startsWith(ignored)) - } map { - _.toString - } mkString newline) - } - } - } - - message.toString - } - - private def logContext(message: StringBuilder, loggingEvent: ILoggingEvent) = { - Option(loggingEvent.getMDCPropertyMap).map(_.asScala).filter(_.nonEmpty).foreach { context => - message.append( - context map { case (key, value) => s"$key$FieldSeparator$value" } mkString ("Context: ", " ", newline) - ) - } - } -} diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala index 95df010..ee564de 100644 --- a/src/main/scala/xyz/driver/core/rest.scala +++ b/src/main/scala/xyz/driver/core/rest.scala @@ -25,7 +25,7 @@ import org.slf4j.MDC import pdi.jwt.{Jwt, JwtAlgorithm} import xyz.driver.core.auth._ import xyz.driver.core.time.provider.TimeProvider -import xyz.driver.core.{Name, generators, trace} +import xyz.driver.core.{Name, generators} import scala.concurrent.duration._ import scala.concurrent.{ExecutionContext, Future, Promise} @@ -59,7 +59,7 @@ object `package` { request.headers.filter { h => h.name === ContextHeaders.AuthenticationTokenHeader || h.name === ContextHeaders.TrackingIdHeader || h.name === ContextHeaders.PermissionsTokenHeader || h.name === ContextHeaders.StacktraceHeader || - h.name === ContextHeaders.TracingHeader + h.name === ContextHeaders.TraceHeaderName || h.name === ContextHeaders.SpanHeaderName } map { header => if (header.name === ContextHeaders.AuthenticationTokenHeader) { header.name -> header.value.stripPrefix(ContextHeaders.AuthenticationHeaderPrefix).trim @@ -172,12 +172,14 @@ class AuthorizedServiceRequestContext[U <: User](override val trackingId: String } object ContextHeaders { + import xyz.driver.tracing.TracingDirectives val AuthenticationTokenHeader = "Authorization" val PermissionsTokenHeader = "Permissions" val AuthenticationHeaderPrefix = "Bearer" val TrackingIdHeader = "X-Trace" val StacktraceHeader = "X-Stacktrace" - val TracingHeader = trace.TracingHeaderKey + val TraceHeaderName = TracingDirectives.TraceHeaderName + val SpanHeaderName = TracingDirectives.SpanHeaderName } object AuthProvider { diff --git a/src/main/scala/xyz/driver/core/trace/ExceptionLoggingSizedBufferingTraceConsumer.scala b/src/main/scala/xyz/driver/core/trace/ExceptionLoggingSizedBufferingTraceConsumer.scala deleted file mode 100644 index 399e2c6..0000000 --- a/src/main/scala/xyz/driver/core/trace/ExceptionLoggingSizedBufferingTraceConsumer.scala +++ /dev/null @@ -1,35 +0,0 @@ -package xyz.driver.core.trace - -import com.google.cloud.trace.v1.consumer.FlushableTraceConsumer -import com.google.devtools.cloudtrace.v1.Traces -import com.typesafe.scalalogging.Logger - -import scala.util.control.NonFatal - -/** - * ExceptionLoggingFlushableTraceConsumer simply wraps a flushable trace consumer and catches/logs any exceptions - * @param traceConsumer the flusable trace consumer to wrap - * @param log where to log any exceptions - */ -class ExceptionLoggingFlushableTraceConsumer(traceConsumer: FlushableTraceConsumer, log: Logger) - extends FlushableTraceConsumer { - - private val flushableTraceConsumer = traceConsumer - - private def exceptionLogger(exception: Throwable): Unit = - log.error(s"Encountered exception logging to google $exception") - - override def receive(trace: Traces): Unit = - try { - flushableTraceConsumer.receive(trace) - } catch { - case NonFatal(e) => exceptionLogger(e) - } - - override def flush(): Unit = - try { - flushableTraceConsumer.flush() - } catch { - case NonFatal(e) => exceptionLogger(e) - } -} diff --git a/src/main/scala/xyz/driver/core/trace/GoogleServiceTracer.scala b/src/main/scala/xyz/driver/core/trace/GoogleServiceTracer.scala deleted file mode 100644 index ead4c6f..0000000 --- a/src/main/scala/xyz/driver/core/trace/GoogleServiceTracer.scala +++ /dev/null @@ -1,14 +0,0 @@ -package xyz.driver.core.trace - -import akka.http.scaladsl.model.headers.RawHeader -import com.google.cloud.trace.Tracer -import com.google.cloud.trace.core.{SpanContextFactory, TraceContext} - -final case class GoogleStackdriverTraceSpan(tracer: Tracer, context: TraceContext) extends CanMakeHeader { - def header: RawHeader = - RawHeader(TracingHeaderKey, SpanContextFactory.toHeader(context.getHandle.getCurrentSpanContext)) -} - -trait GoogleServiceTracer extends ServiceTracer { - type TracerSpanPayload = GoogleStackdriverTraceSpan -} diff --git a/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTrace.scala b/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTrace.scala deleted file mode 100644 index fe4bb5c..0000000 --- a/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTrace.scala +++ /dev/null @@ -1,56 +0,0 @@ -package xyz.driver.core.trace - -import java.io.FileInputStream -import java.nio.file.{Files, Paths} -import java.util - -import akka.http.scaladsl.model.HttpRequest -import com.google.auth.oauth2.GoogleCredentials -import com.google.cloud.trace.grpc.v1.GrpcTraceConsumer -import com.google.cloud.trace.v1.consumer.TraceConsumer -import com.typesafe.scalalogging.Logger - -final class GoogleStackdriverTrace(projectId: String, - clientSecretsFile: String, - appName: String, - appEnvironment: String, - log: Logger, - bufferSize: Int = 1024, - scheduledDelay: Int = 15) - extends GoogleServiceTracer { - - // initialize our various tracking storage systems - private val clientSecretsInputStreamOpt: Option[FileInputStream] = if (Files.exists(Paths.get(clientSecretsFile))) { - Some(new FileInputStream(clientSecretsFile)) - } else { - None - } - // if the google credentials are invalid, just log the traces - private val traceConsumer: TraceConsumer = clientSecretsInputStreamOpt.fold[TraceConsumer] { - log.warn(s"Google credentials not found in path: $clientSecretsFile") - new LoggingTraceConsumer(log) - } { clientSecretsInputStream => - GrpcTraceConsumer - .createWithCredentials( - GoogleCredentials - .fromStream(clientSecretsInputStream) - .createScoped(util.Arrays.asList("https://www.googleapis.com/auth/trace.append")) - ) - } - - private val googleServiceTracer = - new GoogleStackdriverTraceWithConsumer(projectId, - appName, - appEnvironment, - traceConsumer, - log, - bufferSize, - scheduledDelay) - - override def startSpan(httpRequest: HttpRequest): GoogleStackdriverTraceSpan = - googleServiceTracer.startSpan(httpRequest) - - override def endSpan(span: GoogleStackdriverTraceSpan): Unit = googleServiceTracer.endSpan(span) - - override def flush(): Unit = googleServiceTracer.flush() -} diff --git a/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTraceWithConsumer.scala b/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTraceWithConsumer.scala deleted file mode 100644 index ca1eab2..0000000 --- a/src/main/scala/xyz/driver/core/trace/GoogleStackdriverTraceWithConsumer.scala +++ /dev/null @@ -1,95 +0,0 @@ -package xyz.driver.core.trace - -import akka.http.scaladsl.model.HttpRequest -import com.google.cloud.trace.core._ -import com.google.cloud.trace.sink.TraceSink -import com.google.cloud.trace.v1.TraceSinkV1 -import com.google.cloud.trace.v1.consumer.{ScheduledBufferingTraceConsumer, TraceConsumer} -import com.google.cloud.trace.v1.producer.TraceProducer -import com.google.cloud.trace.{SpanContextHandler, SpanContextHandlerTracer, Tracer} -import com.typesafe.scalalogging.Logger -import java.util.concurrent.ScheduledThreadPoolExecutor -import java.util.concurrent.TimeUnit - -import scala.compat.java8.OptionConverters._ - -final class GoogleStackdriverTraceWithConsumer(projectId: String, - appName: String, - appEnvironment: String, - traceConsumer: TraceConsumer, - log: Logger, - bufferSize: Int, - scheduledDelay: Int) - extends GoogleServiceTracer { - - private val traceProducer: TraceProducer = new TraceProducer() - // use a UnitTraceSizer so the interpretation of bufferSize is # of spans to hold in memory prior to flushing - - // now set up the scheduled executor for time-based flushing of our tracing - // see https://goo.gl/HrPLuC - private val scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1) // this is just used for it's timing execution - scheduledThreadPoolExecutor.setKeepAliveTime(scheduledDelay.toLong, TimeUnit.SECONDS) - scheduledThreadPoolExecutor.allowCoreThreadTimeOut(true) - private val executorService = scheduledThreadPoolExecutor - private val threadSafeBufferingTraceConsumer = new ExceptionLoggingFlushableTraceConsumer( - new ScheduledBufferingTraceConsumer(traceConsumer, - new UnitTraceSizer(), - bufferSize, - scheduledDelay, - executorService), - log - ) - - private val traceSink: TraceSink = new TraceSinkV1(projectId, traceProducer, threadSafeBufferingTraceConsumer) - - private val spanContextFactory: SpanContextFactory = new SpanContextFactory( - new ConstantTraceOptionsFactory(true, true)) - private val timestampFactory: TimestampFactory = new JavaTimestampFactory() - - override def startSpan(httpRequest: HttpRequest): TracerSpanPayload = { - val parentHeaderOption: Option[akka.http.javadsl.model.HttpHeader] = - httpRequest.getHeader(TracingHeaderKey).asScala - val (spanContext: SpanContext, spanKind: SpanKind) = parentHeaderOption.fold { - (spanContextFactory.initialContext(), SpanKind.RPC_CLIENT) - } { parentHeader => - (spanContextFactory.fromHeader(parentHeader.value()), SpanKind.RPC_SERVER) - } - - val contextHandler: SpanContextHandler = new SimpleSpanContextHandler(spanContext) - val httpMethod = httpRequest.method.value - val httpHost = httpRequest.uri.authority.host.address() - val httpRelative = httpRequest.uri.toRelative.toString() - val tracer: Tracer = new SpanContextHandlerTracer(traceSink, contextHandler, spanContextFactory, timestampFactory) - // Create a span using the given timestamps. - // https://cloud.google.com/trace/docs/reference/v1/rest/v1/projects.traces#TraceSpan - val spanOptions: StartSpanOptions = (new StartSpanOptions()).setSpanKind(spanKind) - - val spanLabelBuilder = Labels - .builder() - .add("/http/method", httpMethod) - .add("/http/url", httpRelative) - .add("/http/host", httpHost) - .add("/component", appName) - .add("/environment", appEnvironment) - - parentHeaderOption.foreach { parentHeader => - spanLabelBuilder.add("/span/parent", parentHeader.value()) - } - - // The cloudTrace analysis reporting UI makes it easy to query by name prefix. - // this spanName gives us the ability to grab things that are specific to a particular UDE/env, as well as all - // endpoints in that service, as well as a particular endpoint in a particular environment/service. - val spanName: String = s"($appEnvironment->$appName)$httpRelative" - - val context: TraceContext = tracer.startSpan(spanName, spanOptions) - tracer.annotateSpan(context, spanLabelBuilder.build()) - GoogleStackdriverTraceSpan(tracer, context) - } - - override def endSpan(span: TracerSpanPayload): Unit = { - span.tracer.endSpan(span.context) - } - - override def flush(): Unit = threadSafeBufferingTraceConsumer.flush() // flush out the thread safe buffer - -} diff --git a/src/main/scala/xyz/driver/core/trace/LoggingTrace.scala b/src/main/scala/xyz/driver/core/trace/LoggingTrace.scala deleted file mode 100644 index 6a13708..0000000 --- a/src/main/scala/xyz/driver/core/trace/LoggingTrace.scala +++ /dev/null @@ -1,27 +0,0 @@ -package xyz.driver.core.trace - -import akka.http.scaladsl.model.HttpRequest -import com.google.cloud.trace.v1.consumer.TraceConsumer -import com.typesafe.scalalogging.Logger - -final class LoggingTrace(appName: String, appEnvironment: String, log: Logger, bufferSize: Int, scheduledDelay: Int) - extends GoogleServiceTracer { - - private val traceConsumer: TraceConsumer = new LoggingTraceConsumer(log) - private val googleServiceTracer = new GoogleStackdriverTraceWithConsumer( - "logging-tracer", - appName, - appEnvironment, - traceConsumer, - log, - bufferSize, - scheduledDelay - ) - - override def startSpan(httpRequest: HttpRequest): GoogleStackdriverTraceSpan = - googleServiceTracer.startSpan(httpRequest) - - override def endSpan(span: GoogleStackdriverTraceSpan): Unit = googleServiceTracer.endSpan(span) - - override def flush(): Unit = googleServiceTracer.flush() -} diff --git a/src/main/scala/xyz/driver/core/trace/LoggingTraceConsumer.scala b/src/main/scala/xyz/driver/core/trace/LoggingTraceConsumer.scala deleted file mode 100644 index 24df94a..0000000 --- a/src/main/scala/xyz/driver/core/trace/LoggingTraceConsumer.scala +++ /dev/null @@ -1,11 +0,0 @@ -package xyz.driver.core.trace - -import com.google.cloud.trace.v1.consumer.TraceConsumer -import com.google.devtools.cloudtrace.v1.Traces -import com.typesafe.scalalogging.Logger - -class LoggingTraceConsumer(log: Logger) extends TraceConsumer { - def receive(traces: Traces): Unit = { - log.trace(s"Received traces: $traces") - } -} diff --git a/src/main/scala/xyz/driver/core/trace/ServiceTracer.scala b/src/main/scala/xyz/driver/core/trace/ServiceTracer.scala deleted file mode 100644 index 1413b63..0000000 --- a/src/main/scala/xyz/driver/core/trace/ServiceTracer.scala +++ /dev/null @@ -1,19 +0,0 @@ -package xyz.driver.core.trace - -import akka.http.scaladsl.model.HttpRequest -import akka.http.scaladsl.model.headers.RawHeader - -trait CanMakeHeader { - def header: RawHeader -} - -trait ServiceTracer { - - type TracerSpanPayload <: CanMakeHeader - - def startSpan(httpRequest: HttpRequest): TracerSpanPayload - - def endSpan(span: TracerSpanPayload): Unit - - def flush(): Unit -} diff --git a/src/main/scala/xyz/driver/core/trace/SimpleSpanContextHandler.scala b/src/main/scala/xyz/driver/core/trace/SimpleSpanContextHandler.scala deleted file mode 100644 index 4ea0e8c..0000000 --- a/src/main/scala/xyz/driver/core/trace/SimpleSpanContextHandler.scala +++ /dev/null @@ -1,17 +0,0 @@ -package xyz.driver.core.trace - -import com.google.cloud.trace.SpanContextHandler -import com.google.cloud.trace.DetachedSpanContextHandle -import com.google.cloud.trace.core.{SpanContext, SpanContextHandle} - -@SuppressWarnings(Array("org.wartremover.warts.Var")) -class SimpleSpanContextHandler(rootSpan: SpanContext) extends SpanContextHandler { - private var currentSpanContext = rootSpan - - override def current(): SpanContext = currentSpanContext - - override def attach(context: SpanContext): SpanContextHandle = { - currentSpanContext = context - new DetachedSpanContextHandle(context) - } -} diff --git a/src/main/scala/xyz/driver/core/trace/UnitTraceSizer.scala b/src/main/scala/xyz/driver/core/trace/UnitTraceSizer.scala deleted file mode 100644 index a7d6032..0000000 --- a/src/main/scala/xyz/driver/core/trace/UnitTraceSizer.scala +++ /dev/null @@ -1,7 +0,0 @@ -package xyz.driver.core.trace -import com.google.cloud.trace.v1.util.Sizer -import com.google.devtools.cloudtrace.v1.Trace - -class UnitTraceSizer extends Sizer[Trace] { - override def size(sizeable: Trace) = 1 -} diff --git a/src/main/scala/xyz/driver/core/trace/package.scala b/src/main/scala/xyz/driver/core/trace/package.scala deleted file mode 100644 index 0dec833..0000000 --- a/src/main/scala/xyz/driver/core/trace/package.scala +++ /dev/null @@ -1,6 +0,0 @@ -package xyz.driver.core - -package object trace { - // this happens to be the same as the name google uses, but can be anything we want - val TracingHeaderKey: String = "X-Cloud-Trace-Context" -} diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala index 69dbd9e..437ba3c 100644 --- a/src/test/scala/xyz/driver/core/AuthTest.scala +++ b/src/test/scala/xyz/driver/core/AuthTest.scala @@ -5,7 +5,6 @@ import akka.http.scaladsl.server.AuthenticationFailedRejection.CredentialsReject import akka.http.scaladsl.server.Directives._ import akka.http.scaladsl.server._ import akka.http.scaladsl.testkit.ScalatestRouteTest -import org.scalatest.mockito.MockitoSugar import org.scalatest.{FlatSpec, Matchers} import pdi.jwt.{Jwt, JwtAlgorithm} import xyz.driver.core.auth._ @@ -16,7 +15,7 @@ import xyz.driver.core.rest._ import scala.concurrent.Future import scalaz.OptionT -class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRouteTest { +class AuthTest extends FlatSpec with Matchers with ScalatestRouteTest { case object TestRoleAllowedPermission extends Permission case object TestRoleAllowedByTokenPermission extends Permission diff --git a/src/test/scala/xyz/driver/core/MessagesTest.scala b/src/test/scala/xyz/driver/core/MessagesTest.scala index 09558bc..3b891d3 100644 --- a/src/test/scala/xyz/driver/core/MessagesTest.scala +++ b/src/test/scala/xyz/driver/core/MessagesTest.scala @@ -10,7 +10,7 @@ import xyz.driver.core.logging.NoLogger import scala.collection.JavaConverters._ -class MessagesTest extends FlatSpec with Matchers with MockitoSugar { +class MessagesTest extends FlatSpec with Matchers { val englishLocaleMessages = Map("en.greeting" -> "Hello {0}!", "en.greetingFullName" -> "Hello {0} {1} {2}!", "en.hello" -> "Hello world!") -- cgit v1.2.3