+ adds configurable operation name mappings for http client instrumen…

…tation

instrumentation/kamon-akka-http/src/main/scala/kamon/instrumentation/akka/http/AkkaHttpInstrumentation.scala

@@ -1,12 +1,10 @@
 package kamon.instrumentation.akka.http
 
-import akka.http.scaladsl.model.{HttpHeader, HttpRequest, HttpResponse}
+import akka.http.scaladsl.model.{HttpRequest, HttpResponse}
 import akka.http.scaladsl.model.headers.RawHeader
 import kamon.Kamon
 import kamon.instrumentation.http.HttpMessage
 
-import scala.collection.immutable
-
 object AkkaHttpInstrumentation {
 
   Kamon.onReconfigure(_ => AkkaHttpClientInstrumentation.rebuildHttpClientInstrumentation(): Unit)

instrumentation/kamon-akka-http/src/test/resources/application.conf

@@ -148,4 +148,14 @@ kamon.instrumentation.akka.http {
       }
     }
   }
+
+  client {
+    tracing {
+      operations {
+        mappings {
+          "/name-will-be-changed" = "named-via-config"
+        }
+      }
+    }
+  }
 }

instrumentation/kamon-akka-http/src/test/scala/kamon/akka/http/AkkaHttpClientTracingSpec.scala

@@ -24,7 +24,8 @@ import akka.stream.ActorMaterializer
 import kamon.Kamon
 import kamon.testkit._
 import kamon.trace.Span
-import kamon.tag.Lookups.{plain, plainLong, plainBoolean}
+import kamon.tag.Lookups.{plain, plainBoolean, plainLong}
+import okhttp3.Request
 import org.scalatest.concurrent.Eventually
 import org.scalatest.{BeforeAndAfterAll, Matchers, OptionValues, WordSpecLike}
 import org.json4s._
@@ -115,6 +116,16 @@ class AkkaHttpClientTracingSpec extends WordSpecLike with Matchers with BeforeAn
         span.hasError shouldBe true
       }
     }
+
+    "keep operation names provided by the HTTP Server instrumentation" in {
+      val target = s"http://$interface:$port/name-will-be-changed"
+      Http().singleRequest(HttpRequest(uri = target)).map(_.discardEntityBytes())
+
+      eventually(timeout(10 seconds)) {
+        val span = testSpanReporter().nextSpan().value
+        span.operationName shouldBe "named-via-config"
+      }
+    }
   }
 
   override protected def afterAll(): Unit = {

instrumentation/kamon-instrumentation-common/src/main/resources/reference.conf

@@ -218,6 +218,26 @@ kamon {
             #   - method: Uses the request HTTP method as the operation name.
             #
             name-generator = "method"
+
+            # Provides custom mappings from HTTP paths into operation names. Meant to be used in cases where the bytecode
+            # instrumentation is not able to provide a sensible operation name that is free of high cardinality values.
+            # For example, with the following configuration:
+            #   mappings {
+            #     "/organization/*/user/*/profile" = "/organization/:orgID/user/:userID/profile"
+            #     "/events/*/rsvps" = "EventRSVPs"
+            #   }
+            #
+            # Client requests to "/organization/3651/user/39652/profile" and "/organization/22234/user/54543/profile" will have
+            # the same operation name "/organization/:orgID/user/:userID/profile".
+            #
+            # Similarly, requests to "/events/aaa-bb-ccc/rsvps" and "/events/1234/rsvps" will have the same operation
+            # name "EventRSVPs".
+            #
+            # The patterns are expressed as globs and the operation names are free form.
+            #
+            mappings {
+
+            }
           }
         }
       }

instrumentation/kamon-instrumentation-common/src/main/scala/kamon/instrumentation/http/HttpClientInstrumentation.scala

@@ -5,11 +5,13 @@ package http
 import com.typesafe.config.Config
 import kamon.context.Context
 import kamon.instrumentation.http.HttpClientInstrumentation.Settings
+import kamon.instrumentation.http.HttpInstrumentation.OperationNameSettings
 import kamon.instrumentation.tag.TagKeys
 import kamon.instrumentation.trace.SpanTagger
 import kamon.instrumentation.trace.SpanTagger.TagMode
 import kamon.tag.Lookups.option
 import kamon.trace.Span
+import kamon.util.Filter
 import org.slf4j.LoggerFactory
 
 import scala.util.Try
@@ -131,7 +133,7 @@ object HttpClientInstrumentation {
 
     private def createClientSpan(requestMessage: HttpMessage.Request, context: Context): Span = {
       val span = Kamon
-        .clientSpanBuilder(operationName(requestMessage), component)
+        .clientSpanBuilder(HttpInstrumentation.operationName(settings.operationNameSettings, requestMessage), component)
         .context(context)
 
       if(!settings.enableSpanMetrics)
@@ -149,12 +151,9 @@ object HttpClientInstrumentation {
 
       span.start()
     }
-
-    private def operationName(requestMessage: HttpMessage.Request): String =
-      settings.operationNameGenerator.name(requestMessage).getOrElse(settings.defaultOperationName)
   }
 
-  case class Settings (
+  final case class Settings (
     enableContextPropagation: Boolean,
     propagationChannel: String,
     enableTracing: Boolean,
@@ -164,8 +163,11 @@ object HttpClientInstrumentation {
     statusCodeTagMode: TagMode,
     contextTags: Map[String, TagMode],
     defaultOperationName: String,
+    operationMappings: Map[Filter.Glob, String],
     operationNameGenerator: HttpOperationNameGenerator
-  )
+  ) {
+    val operationNameSettings = OperationNameSettings(defaultOperationName, operationMappings, operationNameGenerator)
+  }
 
   object Settings {
 
@@ -197,6 +199,9 @@ object HttpClientInstrumentation {
           _log.warn("Failed to create an HTTP Operation Name Generator, falling back to the default operation name", t)
           new HttpOperationNameGenerator.Static(defaultOperationName)
       }
+      val operationMappings = config.getConfig("tracing.operations.mappings").pairs.map {
+        case (pattern, operationName) => (Filter.Glob(pattern), operationName)
+      }
 
       Settings(
         enablePropagation,
@@ -208,6 +213,7 @@ object HttpClientInstrumentation {
         statusCodeTagMode,
         contextTags,
         defaultOperationName,
+        operationMappings,
         operationNameGenerator.get
       )
     }

instrumentation/kamon-instrumentation-common/src/main/scala/kamon/instrumentation/http/HttpInstrumentation.scala

@@ -0,0 +1,21 @@
+package kamon.instrumentation.http
+
+import kamon.util.Filter
+
+object HttpInstrumentation {
+
+  final case class OperationNameSettings(defaultOperationName: String,
+                                         operationMappings: Map[Filter.Glob, String],
+                                         operationNameGenerator: HttpOperationNameGenerator)
+
+  private[http] def operationName(settings: OperationNameSettings, request: HttpMessage.Request): String = {
+    val requestPath = request.path
+    //first apply any mappings rules
+    val customMapping = settings.operationMappings.collectFirst {
+      case (pattern, operationName) if pattern.accept(requestPath) => operationName
+    }.orElse( //fallback to use any configured name generator
+      settings.operationNameGenerator.name(request)
+    )
+    customMapping.getOrElse(settings.defaultOperationName)
+  }
+}

instrumentation/kamon-instrumentation-common/src/main/scala/kamon/instrumentation/http/HttpServerInstrumentation.scala

@@ -6,6 +6,7 @@ import java.time.Duration
 
 import com.typesafe.config.Config
 import kamon.context.Context
+import kamon.instrumentation.http.HttpInstrumentation.OperationNameSettings
 import kamon.instrumentation.http.HttpServerInstrumentation.Settings
 import kamon.instrumentation.trace.SpanTagger.TagMode
 import kamon.instrumentation.tag.TagKeys
@@ -295,7 +296,7 @@ object HttpServerInstrumentation {
 
 
     private def buildServerSpan(context: Context, request: HttpMessage.Request, deferSamplingDecision: Boolean): Span = {
-      val span = Kamon.serverSpanBuilder(operationName(request), component)
+      val span = Kamon.serverSpanBuilder(HttpInstrumentation.operationName(settings.operationNameSettings, request), component)
       span.context(context)
 
       if(!settings.enableSpanMetrics)
@@ -322,21 +323,10 @@ object HttpServerInstrumentation {
 
       span.start()
     }
-
-    private def operationName(request: HttpMessage.Request): String = {
-      val requestPath = request.path
-      //first apply any mappings rules
-      val customMapping = settings.operationMappings.collectFirst {
-        case (pattern, operationName) if pattern.accept(requestPath) => operationName
-      }.orElse( //fallback to use any configured name generator
-        settings.operationNameGenerator.name(request)
-     )
-      customMapping.getOrElse(settings.defaultOperationName)
-    }
   }
 
 
-  case class Settings(
+  final case class Settings(
     enableContextPropagation: Boolean,
     propagationChannel: String,
     enableServerMetrics: Boolean,
@@ -353,7 +343,9 @@ object HttpServerInstrumentation {
     unhandledOperationName: String,
     operationMappings: Map[Filter.Glob, String],
     operationNameGenerator: HttpOperationNameGenerator
-  )
+  ) {
+    val operationNameSettings = OperationNameSettings(defaultOperationName, operationMappings, operationNameGenerator)
+  }
 
   object Settings {
 
@@ -395,7 +387,7 @@ object HttpServerInstrumentation {
       }
       val unhandledOperationName = config.getString("tracing.operations.unhandled")
       val operationMappings = config.getConfig("tracing.operations.mappings").pairs.map {
-        case (pattern, operationName) => (new Filter.Glob(pattern), operationName)
+        case (pattern, operationName) => (Filter.Glob(pattern), operationName)
       }
 
       Settings(

instrumentation/kamon-instrumentation-common/src/test/resources/application.conf

@@ -50,6 +50,16 @@ kamon {
     }
 
     http-client {
+      default {
+        tracing {
+          operations {
+            default = "default-name"
+            mappings {
+              "/events/*/rsvps" = "EventRSVPs"
+            }
+          }
+        }
+      }
 
       no-span-metrics {
         tracing.span-metrics = off

instrumentation/kamon-instrumentation-common/src/test/scala/kamon/instrumentation/http/HttpClientInstrumentationSpec.scala

@@ -83,6 +83,18 @@ class HttpClientInstrumentationSpec extends WordSpec with Matchers with Instrume
         handler.request.read("X-B3-ParentSpanId").value shouldBe parent.id.string
         handler.request.read("X-B3-Sampled") shouldBe defined
       }
+
+      "honour user provided operation name mappings" in {
+        val handler = httpClient().createHandler(fakeRequest("http://localhost:8080/", "/events/123/rsvps", "GET", Map.empty), Context.Empty)
+        handler.processResponse(fakeResponse(200))
+
+        val span = handler.span
+        span.operationName() shouldBe "EventRSVPs"
+        span.tags().get(plain("http.method")) shouldBe "GET"
+        span.tags().get(plain("http.url")) shouldBe "http://localhost:8080/"
+        span.tags().get(plainLong("http.status_code")) shouldBe 200
+        span.tags().get(plain("operation")) shouldBe "EventRSVPs"
+      }
     }
 
     "all capabilities are disabled" should {