Merge pull request #72 from drivergroup/jstjohn/update-tracingv1.4.2v1.4.0

cleanup logging, remove old tracing, use new tracing library

16 files changed, 62 insertions, 414 deletions

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..19eef52 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.TracingDirectives._
+import xyz.driver.tracing._
 
 import scala.compat.Platform.ConcurrentModificationException
 import scala.concurrent.duration._
@@ -47,14 +48,12 @@ object app {
                   baseUrl: String = "localhost:8080",
                   scheme: String = "http",
                   port: Int = 8080,
-                  tracer: Option[ServiceTracer] = None)(implicit actorSystem: ActorSystem,
-                                                        executionContext: ExecutionContext) {
+                  tracer: Tracer = NoTracer)(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))
+
     def run(): Unit = {
       activateServices(modules)
       scheduleServicesDeactivation(modules)
@@ -64,8 +63,8 @@ object app {
 
     def stop(): Unit = {
       http.shutdownAllConnectionPools().onComplete { _ =>
-        val _ = actorSystem.terminate()
-        serviceTracer.flush() // flush out any remaining traces from the buffer
+        Await.result(tracer.close(), 15.seconds) // 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 ")
@@ -89,14 +88,15 @@ object app {
         "Server",
         "Date",
         ContextHeaders.TrackingIdHeader,
+        ContextHeaders.TraceHeaderName,
+        ContextHeaders.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 +136,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(tracer) {
+              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..08b00b4 100644
--- a/src/test/scala/xyz/driver/core/MessagesTest.scala
+++ b/src/test/scala/xyz/driver/core/MessagesTest.scala
@@ -3,14 +3,13 @@ package xyz.driver.core
 import java.util.Locale
 
 import com.typesafe.config.{ConfigException, ConfigFactory}
-import org.scalatest.mockito.MockitoSugar
 import org.scalatest.{FlatSpec, Matchers}
 import xyz.driver.core.messages.Messages
 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!")